Socket
Socket
Sign inDemoInstall

react-refresh

Package Overview
Dependencies
0
Maintainers
10
Versions
1641
Alerts
File Explorer

Advanced tools

npm Scripts
License

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 0.0.0-experimental-a515d753b-20240220 to 0.0.0-experimental-a532d91d01-20240610

2

babel.js
'use strict';
if (process.env.NODE_ENV === 'production') {
module.exports = require('./cjs/react-refresh-babel.production.min.js');
module.exports = require('./cjs/react-refresh-babel.production.js');
} else {
module.exports = require('./cjs/react-refresh-babel.development.js');
}

1347

cjs/react-refresh-babel.development.js

@@ -11,849 +11,592 @@ /**

'use strict';
if (process.env.NODE_ENV !== "production") {
(function() {
'use strict';
function ReactFreshBabelPlugin (babel) {
var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
if (typeof babel.env === 'function') {
// Only available in Babel 7.
var env = babel.env();
if (env !== 'development' && !opts.skipEnvCheck) {
throw new Error('React Refresh Babel transform should only be enabled in development environment. ' + 'Instead, the environment is: "' + env + '". If you want to override this check, pass {skipEnvCheck: true} as plugin options.');
"use strict";
"production" !== process.env.NODE_ENV &&
(module.exports = function (babel) {
function createRegistration(programPath, persistentID) {
var handle = programPath.scope.generateUidIdentifier("c");
registrationsByProgramPath.has(programPath) ||
registrationsByProgramPath.set(programPath, []);
registrationsByProgramPath
.get(programPath)
.push({ handle: handle, persistentID: persistentID });
return handle;
}
}
var t = babel.types;
var refreshReg = t.identifier(opts.refreshReg || '$RefreshReg$');
var refreshSig = t.identifier(opts.refreshSig || '$RefreshSig$');
var registrationsByProgramPath = new Map();
function createRegistration(programPath, persistentID) {
var handle = programPath.scope.generateUidIdentifier('c');
if (!registrationsByProgramPath.has(programPath)) {
registrationsByProgramPath.set(programPath, []);
function isComponentishName(name) {
return "string" === typeof name && "A" <= name[0] && "Z" >= name[0];
}
var registrations = registrationsByProgramPath.get(programPath);
registrations.push({
handle: handle,
persistentID: persistentID
});
return handle;
}
function isComponentishName(name) {
return typeof name === 'string' && name[0] >= 'A' && name[0] <= 'Z';
}
function findInnerComponents(inferredName, path, callback) {
var node = path.node;
switch (node.type) {
case 'Identifier':
{
if (!isComponentishName(node.name)) {
return false;
} // export default hoc(Foo)
// const X = hoc(Foo)
function findInnerComponents(inferredName, path, callback) {
var node = path.node;
switch (node.type) {
case "Identifier":
if (!isComponentishName(node.name)) break;
callback(inferredName, node, null);
return true;
}
case 'FunctionDeclaration':
{
// function Foo() {}
// export function Foo() {}
// export default function Foo() {}
callback(inferredName, node.id, null);
return true;
}
case 'ArrowFunctionExpression':
{
if (node.body.type === 'ArrowFunctionExpression') {
return false;
} // let Foo = () => {}
// export default hoc1(hoc2(() => {}))
return !0;
case "FunctionDeclaration":
return callback(inferredName, node.id, null), !0;
case "ArrowFunctionExpression":
if ("ArrowFunctionExpression" === node.body.type) break;
callback(inferredName, node, path);
return true;
}
case 'FunctionExpression':
{
// let Foo = function() {}
// const Foo = hoc1(forwardRef(function renderFoo() {}))
// export default memo(function() {})
callback(inferredName, node, path);
return true;
}
case 'CallExpression':
{
var argsPath = path.get('arguments');
if (argsPath === undefined || argsPath.length === 0) {
return false;
}
var calleePath = path.get('callee');
return !0;
case "FunctionExpression":
return callback(inferredName, node, path), !0;
case "CallExpression":
var argsPath = path.get("arguments");
if (void 0 === argsPath || 0 === argsPath.length) break;
var calleePath = path.get("callee");
switch (calleePath.node.type) {
case 'MemberExpression':
case 'Identifier':
{
var calleeSource = calleePath.getSource();
var firstArgPath = argsPath[0];
var innerName = inferredName + '$' + calleeSource;
var foundInside = findInnerComponents(innerName, firstArgPath, callback);
if (!foundInside) {
return false;
} // const Foo = hoc1(hoc2(() => {}))
// export default memo(React.forwardRef(function() {}))
callback(inferredName, node, path);
return true;
}
case "MemberExpression":
case "Identifier":
calleePath = calleePath.getSource();
if (
!findInnerComponents(
inferredName + "$" + calleePath,
argsPath[0],
callback
)
)
return !1;
callback(inferredName, node, path);
return !0;
default:
{
return false;
}
return !1;
}
}
case 'VariableDeclarator':
{
var init = node.init;
if (init === null) {
return false;
}
var name = node.id.name;
if (!isComponentishName(name)) {
return false;
}
switch (init.type) {
case 'ArrowFunctionExpression':
case 'FunctionExpression':
// Likely component definitions.
break;
case 'CallExpression':
{
// Maybe a HOC.
// Try to determine if this is some form of import.
var callee = init.callee;
var calleeType = callee.type;
if (calleeType === 'Import') {
return false;
} else if (calleeType === 'Identifier') {
if (callee.name.indexOf('require') === 0) {
return false;
} else if (callee.name.indexOf('import') === 0) {
return false;
} // Neither require nor import. Might be a HOC.
// Pass through.
} else ;
case "VariableDeclarator":
if (
((argsPath = node.init),
null !== argsPath &&
((calleePath = node.id.name), isComponentishName(calleePath)))
) {
switch (argsPath.type) {
case "ArrowFunctionExpression":
case "FunctionExpression":
break;
}
case 'TaggedTemplateExpression':
// Maybe something like styled.div`...`
break;
default:
return false;
}
var initPath = path.get('init');
var _foundInside = findInnerComponents(inferredName, initPath, callback);
if (_foundInside) {
return true;
} // See if this identifier is used in JSX. Then it's a component.
var binding = path.scope.getBinding(name);
if (binding === undefined) {
return;
}
var isLikelyUsedAsType = false;
var referencePaths = binding.referencePaths;
for (var i = 0; i < referencePaths.length; i++) {
var ref = referencePaths[i];
if (ref.node && ref.node.type !== 'JSXIdentifier' && ref.node.type !== 'Identifier') {
continue;
case "CallExpression":
node = argsPath.callee;
var calleeType = node.type;
if (
"Import" === calleeType ||
("Identifier" === calleeType &&
(0 === node.name.indexOf("require") ||
0 === node.name.indexOf("import")))
)
return !1;
break;
case "TaggedTemplateExpression":
break;
default:
return !1;
}
var refParent = ref.parent;
if (refParent.type === 'JSXOpeningElement') {
isLikelyUsedAsType = true;
} else if (refParent.type === 'CallExpression') {
var _callee = refParent.callee;
var fnName = void 0;
switch (_callee.type) {
case 'Identifier':
fnName = _callee.name;
break;
case 'MemberExpression':
fnName = _callee.property.name;
break;
node = path.get("init");
if (findInnerComponents(inferredName, node, callback)) return !0;
calleePath = path.scope.getBinding(calleePath);
if (void 0 === calleePath) return;
path = !1;
calleePath = calleePath.referencePaths;
for (calleeType = 0; calleeType < calleePath.length; calleeType++) {
var ref = calleePath[calleeType];
if (
!ref.node ||
"JSXIdentifier" === ref.node.type ||
"Identifier" === ref.node.type
) {
ref = ref.parent;
if ("JSXOpeningElement" === ref.type) path = !0;
else if ("CallExpression" === ref.type) {
ref = ref.callee;
var fnName = void 0;
switch (ref.type) {
case "Identifier":
fnName = ref.name;
break;
case "MemberExpression":
fnName = ref.property.name;
}
switch (fnName) {
case "createElement":
case "jsx":
case "jsxDEV":
case "jsxs":
path = !0;
}
}
if (path) return callback(inferredName, argsPath, node), !0;
}
switch (fnName) {
case 'createElement':
case 'jsx':
case 'jsxDEV':
case 'jsxs':
isLikelyUsedAsType = true;
break;
}
}
if (isLikelyUsedAsType) {
// const X = ... + later <X />
callback(inferredName, init, initPath);
return true;
}
}
}
}
return !1;
}
return false;
}
function isBuiltinHook(hookName) {
switch (hookName) {
case 'useState':
case 'React.useState':
case 'useReducer':
case 'React.useReducer':
case 'useEffect':
case 'React.useEffect':
case 'useLayoutEffect':
case 'React.useLayoutEffect':
case 'useMemo':
case 'React.useMemo':
case 'useCallback':
case 'React.useCallback':
case 'useRef':
case 'React.useRef':
case 'useContext':
case 'React.useContext':
case 'useImperativeHandle':
case 'React.useImperativeHandle':
case 'useDebugValue':
case 'React.useDebugValue':
case 'useId':
case 'React.useId':
case 'useDeferredValue':
case 'React.useDeferredValue':
case 'useTransition':
case 'React.useTransition':
case 'useInsertionEffect':
case 'React.useInsertionEffect':
case 'useSyncExternalStore':
case 'React.useSyncExternalStore':
case 'useFormStatus':
case 'React.useFormStatus':
case 'useFormState':
case 'React.useFormState':
case 'useOptimistic':
case 'React.useOptimistic':
return true;
default:
return false;
function getHookCallsSignature(functionNode) {
functionNode = hookCalls.get(functionNode);
return void 0 === functionNode
? null
: {
key: functionNode
.map(function (call) {
return call.name + "{" + call.key + "}";
})
.join("\n"),
customHooks: functionNode
.filter(function (call) {
a: switch (call.name) {
case "useState":
case "React.useState":
case "useReducer":
case "React.useReducer":
case "useEffect":
case "React.useEffect":
case "useLayoutEffect":
case "React.useLayoutEffect":
case "useMemo":
case "React.useMemo":
case "useCallback":
case "React.useCallback":
case "useRef":
case "React.useRef":
case "useContext":
case "React.useContext":
case "useImperativeHandle":
case "React.useImperativeHandle":
case "useDebugValue":
case "React.useDebugValue":
case "useId":
case "React.useId":
case "useDeferredValue":
case "React.useDeferredValue":
case "useTransition":
case "React.useTransition":
case "useInsertionEffect":
case "React.useInsertionEffect":
case "useSyncExternalStore":
case "React.useSyncExternalStore":
case "useFormStatus":
case "React.useFormStatus":
case "useFormState":
case "React.useFormState":
case "useActionState":
case "React.useActionState":
case "useOptimistic":
case "React.useOptimistic":
call = !0;
break a;
default:
call = !1;
}
return !call;
})
.map(function (call) {
return t.cloneDeep(call.callee);
})
};
}
}
function getHookCallsSignature(functionNode) {
var fnHookCalls = hookCalls.get(functionNode);
if (fnHookCalls === undefined) {
return null;
}
return {
key: fnHookCalls.map(function (call) {
return call.name + '{' + call.key + '}';
}).join('\n'),
customHooks: fnHookCalls.filter(function (call) {
return !isBuiltinHook(call.name);
}).map(function (call) {
return t.cloneDeep(call.callee);
})
};
}
var hasForceResetCommentByFile = new WeakMap(); // We let user do /* @refresh reset */ to reset state in the whole file.
function hasForceResetComment(path) {
var file = path.hub.file;
var hasForceReset = hasForceResetCommentByFile.get(file);
if (hasForceReset !== undefined) {
function hasForceResetComment(path) {
path = path.hub.file;
var hasForceReset = hasForceResetCommentByFile.get(path);
if (void 0 !== hasForceReset) return hasForceReset;
hasForceReset = !1;
for (var comments = path.ast.comments, i = 0; i < comments.length; i++)
if (-1 !== comments[i].value.indexOf("@refresh reset")) {
hasForceReset = !0;
break;
}
hasForceResetCommentByFile.set(path, hasForceReset);
return hasForceReset;
}
hasForceReset = false;
var comments = file.ast.comments;
for (var i = 0; i < comments.length; i++) {
var cmt = comments[i];
if (cmt.value.indexOf('@refresh reset') !== -1) {
hasForceReset = true;
break;
}
function createArgumentsForSignature(node, signature, scope) {
var key = signature.key;
signature = signature.customHooks;
var forceReset = hasForceResetComment(scope.path),
customHooksInScope = [];
signature.forEach(function (callee) {
switch (callee.type) {
case "MemberExpression":
if ("Identifier" === callee.object.type)
var bindingName = callee.object.name;
break;
case "Identifier":
bindingName = callee.name;
}
scope.hasBinding(bindingName)
? customHooksInScope.push(callee)
: (forceReset = !0);
});
signature = key;
"function" !== typeof require ||
opts.emitFullSignatures ||
(signature = require("crypto")
.createHash("sha1")
.update(key)
.digest("base64"));
node = [node, t.stringLiteral(signature)];
(forceReset || 0 < customHooksInScope.length) &&
node.push(t.booleanLiteral(forceReset));
0 < customHooksInScope.length &&
node.push(
t.functionExpression(
null,
[],
t.blockStatement([
t.returnStatement(t.arrayExpression(customHooksInScope))
])
)
);
return node;
}
hasForceResetCommentByFile.set(file, hasForceReset);
return hasForceReset;
}
function createArgumentsForSignature(node, signature, scope) {
var key = signature.key,
customHooks = signature.customHooks;
var forceReset = hasForceResetComment(scope.path);
var customHooksInScope = [];
customHooks.forEach(function (callee) {
// Check if a corresponding binding exists where we emit the signature.
var bindingName;
switch (callee.type) {
case 'MemberExpression':
if (callee.object.type === 'Identifier') {
bindingName = callee.object.name;
}
break;
case 'Identifier':
bindingName = callee.name;
break;
function findHOCCallPathsAbove(path) {
for (var calls = []; ; ) {
if (!path) return calls;
var parentPath = path.parentPath;
if (!parentPath) return calls;
if (
"AssignmentExpression" === parentPath.node.type &&
path.node === parentPath.node.right
)
path = parentPath;
else if (
"CallExpression" === parentPath.node.type &&
path.node !== parentPath.node.callee
)
calls.push(parentPath), (path = parentPath);
else return calls;
}
if (scope.hasBinding(bindingName)) {
customHooksInScope.push(callee);
} else {
// We don't have anything to put in the array because Hook is out of scope.
// Since it could potentially have been edited, remount the component.
forceReset = true;
}
});
var finalKey = key;
if (typeof require === 'function' && !opts.emitFullSignatures) {
// Prefer to hash when we can (e.g. outside of ASTExplorer).
// This makes it deterministically compact, even if there's
// e.g. a useState initializer with some code inside.
// We also need it for www that has transforms like cx()
// that don't understand if something is part of a string.
finalKey = require('crypto').createHash('sha1').update(key).digest('base64');
}
var args = [node, t.stringLiteral(finalKey)];
if (forceReset || customHooksInScope.length > 0) {
args.push(t.booleanLiteral(forceReset));
var opts =
1 < arguments.length && void 0 !== arguments[1] ? arguments[1] : {};
if ("function" === typeof babel.env) {
var env = babel.env();
if ("development" !== env && !opts.skipEnvCheck)
throw Error(
'React Refresh Babel transform should only be enabled in development environment. Instead, the environment is: "' +
env +
'". If you want to override this check, pass {skipEnvCheck: true} as plugin options.'
);
}
if (customHooksInScope.length > 0) {
args.push( // TODO: We could use an arrow here to be more compact.
// However, don't do it until AMA can run them natively.
t.functionExpression(null, [], t.blockStatement([t.returnStatement(t.arrayExpression(customHooksInScope))])));
}
return args;
}
function findHOCCallPathsAbove(path) {
var calls = [];
while (true) {
if (!path) {
return calls;
}
var parentPath = path.parentPath;
if (!parentPath) {
return calls;
}
if ( // hoc(_c = function() { })
parentPath.node.type === 'AssignmentExpression' && path.node === parentPath.node.right) {
// Ignore registrations.
path = parentPath;
continue;
}
if ( // hoc1(hoc2(...))
parentPath.node.type === 'CallExpression' && path.node !== parentPath.node.callee) {
calls.push(parentPath);
path = parentPath;
continue;
}
return calls; // Stop at other types.
}
}
var seenForRegistration = new WeakSet();
var seenForSignature = new WeakSet();
var seenForOutro = new WeakSet();
var hookCalls = new WeakMap();
var HookCallsVisitor = {
CallExpression: function (path) {
var node = path.node;
var callee = node.callee; // Note: this visitor MUST NOT mutate the tree in any way.
// It runs early in a separate traversal and should be very fast.
var name = null;
switch (callee.type) {
case 'Identifier':
name = callee.name;
break;
case 'MemberExpression':
name = callee.property.name;
break;
}
if (name === null || !/^use[A-Z]/.test(name)) {
return;
}
var fnScope = path.scope.getFunctionParent();
if (fnScope === null) {
return;
} // This is a Hook call. Record it.
var fnNode = fnScope.block;
if (!hookCalls.has(fnNode)) {
hookCalls.set(fnNode, []);
}
var hookCallsForFn = hookCalls.get(fnNode);
var key = '';
if (path.parent.type === 'VariableDeclarator') {
// TODO: if there is no LHS, consider some other heuristic.
key = path.parentPath.get('id').getSource();
} // Some built-in Hooks reset on edits to arguments.
var args = path.get('arguments');
if (name === 'useState' && args.length > 0) {
// useState second argument is initial state.
key += '(' + args[0].getSource() + ')';
} else if (name === 'useReducer' && args.length > 1) {
// useReducer second argument is initial state.
key += '(' + args[1].getSource() + ')';
}
hookCallsForFn.push({
callee: path.node.callee,
name: name,
key: key
});
}
};
return {
visitor: {
ExportDefaultDeclaration: function (path) {
var node = path.node;
var decl = node.declaration;
var declPath = path.get('declaration');
if (decl.type !== 'CallExpression') {
// For now, we only support possible HOC calls here.
// Named function declarations are handled in FunctionDeclaration.
// Anonymous direct exports like export default function() {}
// are currently ignored.
return;
} // Make sure we're not mutating the same tree twice.
// This can happen if another Babel plugin replaces parents.
if (seenForRegistration.has(node)) {
return;
var t = babel.types,
refreshReg = t.identifier(opts.refreshReg || "$RefreshReg$"),
refreshSig = t.identifier(opts.refreshSig || "$RefreshSig$"),
registrationsByProgramPath = new Map(),
hasForceResetCommentByFile = new WeakMap(),
seenForRegistration = new WeakSet(),
seenForSignature = new WeakSet(),
seenForOutro = new WeakSet(),
hookCalls = new WeakMap(),
HookCallsVisitor = {
CallExpression: function (path) {
var callee = path.node.callee,
name = null;
switch (callee.type) {
case "Identifier":
name = callee.name;
break;
case "MemberExpression":
name = callee.property.name;
}
if (
null !== name &&
/^use[A-Z]/.test(name) &&
((callee = path.scope.getFunctionParent()), null !== callee)
) {
callee = callee.block;
hookCalls.has(callee) || hookCalls.set(callee, []);
callee = hookCalls.get(callee);
var key = "";
"VariableDeclarator" === path.parent.type &&
(key = path.parentPath.get("id").getSource());
var args = path.get("arguments");
"useState" === name && 0 < args.length
? (key += "(" + args[0].getSource() + ")")
: "useReducer" === name &&
1 < args.length &&
(key += "(" + args[1].getSource() + ")");
callee.push({ callee: path.node.callee, name: name, key: key });
}
}
seenForRegistration.add(node); // Don't mutate the tree above this point.
// This code path handles nested cases like:
// export default memo(() => {})
// In those cases it is more plausible people will omit names
// so they're worth handling despite possible false positives.
// More importantly, it handles the named case:
// export default memo(function Named() {})
var inferredName = '%default%';
var programPath = path.parentPath;
findInnerComponents(inferredName, declPath, function (persistentID, targetExpr, targetPath) {
if (targetPath === null) {
// For case like:
// export default hoc(Foo)
// we don't want to wrap Foo inside the call.
// Instead we assume it's registered at definition.
return;
};
return {
visitor: {
ExportDefaultDeclaration: function (path) {
var node = path.node,
decl = node.declaration,
declPath = path.get("declaration");
if (
"CallExpression" === decl.type &&
!seenForRegistration.has(node)
) {
seenForRegistration.add(node);
var programPath = path.parentPath;
findInnerComponents(
"%default%",
declPath,
function (persistentID, targetExpr, targetPath) {
null !== targetPath &&
((persistentID = createRegistration(
programPath,
persistentID
)),
targetPath.replaceWith(
t.assignmentExpression("=", persistentID, targetExpr)
));
}
);
}
var handle = createRegistration(programPath, persistentID);
targetPath.replaceWith(t.assignmentExpression('=', handle, targetExpr));
});
},
FunctionDeclaration: {
enter: function (path) {
var node = path.node;
var programPath;
var insertAfterPath;
var modulePrefix = '';
},
FunctionDeclaration: {
enter: function (path) {
var node = path.node,
modulePrefix = "";
switch (path.parent.type) {
case "Program":
var insertAfterPath = path;
var programPath = path.parentPath;
break;
case "TSModuleBlock":
insertAfterPath = path;
programPath = insertAfterPath.parentPath.parentPath;
break;
case "ExportNamedDeclaration":
insertAfterPath = path.parentPath;
programPath = insertAfterPath.parentPath;
break;
case "ExportDefaultDeclaration":
insertAfterPath = path.parentPath;
programPath = insertAfterPath.parentPath;
break;
default:
return;
}
if (
"TSModuleBlock" === path.parent.type ||
"ExportNamedDeclaration" === path.parent.type
)
for (; "Program" !== programPath.type; ) {
if ("TSModuleDeclaration" === programPath.type) {
if (
"Program" !== programPath.parentPath.type &&
"ExportNamedDeclaration" !== programPath.parentPath.type
)
return;
modulePrefix = programPath.node.id.name + "$" + modulePrefix;
}
programPath = programPath.parentPath;
}
var id = node.id;
null !== id &&
((id = id.name),
isComponentishName(id) &&
!seenForRegistration.has(node) &&
(seenForRegistration.add(node),
findInnerComponents(
modulePrefix + id,
path,
function (persistentID, targetExpr) {
persistentID = createRegistration(
programPath,
persistentID
);
insertAfterPath.insertAfter(
t.expressionStatement(
t.assignmentExpression("=", persistentID, targetExpr)
)
);
}
)));
},
exit: function (path) {
var node = path.node,
id = node.id;
if (null !== id) {
var signature = getHookCallsSignature(node);
if (null !== signature && !seenForSignature.has(node)) {
seenForSignature.add(node);
node = path.scope.generateUidIdentifier("_s");
path.scope.parent.push({
id: node,
init: t.callExpression(refreshSig, [])
});
path
.get("body")
.unshiftContainer(
"body",
t.expressionStatement(t.callExpression(node, []))
);
var insertAfterPath = null;
path.find(function (p) {
if (p.parentPath.isBlock()) return (insertAfterPath = p), !0;
});
null !== insertAfterPath &&
insertAfterPath.insertAfter(
t.expressionStatement(
t.callExpression(
node,
createArgumentsForSignature(
id,
signature,
insertAfterPath.scope
)
)
)
);
}
}
}
},
"ArrowFunctionExpression|FunctionExpression": {
exit: function (path) {
var node = path.node,
signature = getHookCallsSignature(node);
if (null !== signature && !seenForSignature.has(node)) {
seenForSignature.add(node);
var sigCallID = path.scope.generateUidIdentifier("_s");
path.scope.parent.push({
id: sigCallID,
init: t.callExpression(refreshSig, [])
});
"BlockStatement" !== path.node.body.type &&
(path.node.body = t.blockStatement([
t.returnStatement(path.node.body)
]));
path
.get("body")
.unshiftContainer(
"body",
t.expressionStatement(t.callExpression(sigCallID, []))
);
if ("VariableDeclarator" === path.parent.type) {
var insertAfterPath = null;
path.find(function (p) {
if (p.parentPath.isBlock()) return (insertAfterPath = p), !0;
});
null !== insertAfterPath &&
insertAfterPath.insertAfter(
t.expressionStatement(
t.callExpression(
sigCallID,
createArgumentsForSignature(
path.parent.id,
signature,
insertAfterPath.scope
)
)
)
);
} else
[path]
.concat(findHOCCallPathsAbove(path))
.forEach(function (p) {
p.replaceWith(
t.callExpression(
sigCallID,
createArgumentsForSignature(p.node, signature, p.scope)
)
);
});
}
}
},
VariableDeclaration: function (path) {
var node = path.node,
modulePrefix = "";
switch (path.parent.type) {
case 'Program':
insertAfterPath = path;
programPath = path.parentPath;
case "Program":
var insertAfterPath = path;
var programPath = path.parentPath;
break;
case 'TSModuleBlock':
case "TSModuleBlock":
insertAfterPath = path;
programPath = insertAfterPath.parentPath.parentPath;
break;
case 'ExportNamedDeclaration':
case "ExportNamedDeclaration":
insertAfterPath = path.parentPath;
programPath = insertAfterPath.parentPath;
break;
case 'ExportDefaultDeclaration':
case "ExportDefaultDeclaration":
insertAfterPath = path.parentPath;
programPath = insertAfterPath.parentPath;
break;
default:
return;
} // These types can be nested in typescript namespace
// We need to find the export chain
// Or return if it stays local
if (path.parent.type === 'TSModuleBlock' || path.parent.type === 'ExportNamedDeclaration') {
while (programPath.type !== 'Program') {
if (programPath.type === 'TSModuleDeclaration') {
if (programPath.parentPath.type !== 'Program' && programPath.parentPath.type !== 'ExportNamedDeclaration') {
}
if (
"TSModuleBlock" === path.parent.type ||
"ExportNamedDeclaration" === path.parent.type
)
for (; "Program" !== programPath.type; ) {
if ("TSModuleDeclaration" === programPath.type) {
if (
"Program" !== programPath.parentPath.type &&
"ExportNamedDeclaration" !== programPath.parentPath.type
)
return;
}
modulePrefix = programPath.node.id.name + '$' + modulePrefix;
modulePrefix = programPath.node.id.name + "$" + modulePrefix;
}
programPath = programPath.parentPath;
}
if (
!seenForRegistration.has(node) &&
(seenForRegistration.add(node),
(path = path.get("declarations")),
1 === path.length)
) {
var declPath = path[0];
findInnerComponents(
modulePrefix + declPath.node.id.name,
declPath,
function (persistentID, targetExpr, targetPath) {
null !== targetPath &&
((persistentID = createRegistration(
programPath,
persistentID
)),
"VariableDeclarator" === targetPath.parent.type
? insertAfterPath.insertAfter(
t.expressionStatement(
t.assignmentExpression(
"=",
persistentID,
declPath.node.id
)
)
)
: targetPath.replaceWith(
t.assignmentExpression("=", persistentID, targetExpr)
));
}
);
}
var id = node.id;
if (id === null) {
// We don't currently handle anonymous default exports.
return;
}
var inferredName = id.name;
if (!isComponentishName(inferredName)) {
return;
} // Make sure we're not mutating the same tree twice.
// This can happen if another Babel plugin replaces parents.
if (seenForRegistration.has(node)) {
return;
}
seenForRegistration.add(node); // Don't mutate the tree above this point.
var innerName = modulePrefix + inferredName; // export function Named() {}
// function Named() {}
findInnerComponents(innerName, path, function (persistentID, targetExpr) {
var handle = createRegistration(programPath, persistentID);
insertAfterPath.insertAfter(t.expressionStatement(t.assignmentExpression('=', handle, targetExpr)));
});
},
exit: function (path) {
var node = path.node;
var id = node.id;
if (id === null) {
return;
}
var signature = getHookCallsSignature(node);
if (signature === null) {
return;
} // Make sure we're not mutating the same tree twice.
// This can happen if another Babel plugin replaces parents.
if (seenForSignature.has(node)) {
return;
}
seenForSignature.add(node); // Don't mutate the tree above this point.
var sigCallID = path.scope.generateUidIdentifier('_s');
path.scope.parent.push({
id: sigCallID,
init: t.callExpression(refreshSig, [])
}); // The signature call is split in two parts. One part is called inside the function.
// This is used to signal when first render happens.
path.get('body').unshiftContainer('body', t.expressionStatement(t.callExpression(sigCallID, []))); // The second call is around the function itself.
// This is used to associate a type with a signature.
// Unlike with $RefreshReg$, this needs to work for nested
// declarations too. So we need to search for a path where
// we can insert a statement rather than hard coding it.
var insertAfterPath = null;
path.find(function (p) {
if (p.parentPath.isBlock()) {
insertAfterPath = p;
return true;
}
});
if (insertAfterPath === null) {
return;
}
insertAfterPath.insertAfter(t.expressionStatement(t.callExpression(sigCallID, createArgumentsForSignature(id, signature, insertAfterPath.scope))));
}
},
'ArrowFunctionExpression|FunctionExpression': {
exit: function (path) {
var node = path.node;
var signature = getHookCallsSignature(node);
if (signature === null) {
return;
} // Make sure we're not mutating the same tree twice.
// This can happen if another Babel plugin replaces parents.
if (seenForSignature.has(node)) {
return;
}
seenForSignature.add(node); // Don't mutate the tree above this point.
var sigCallID = path.scope.generateUidIdentifier('_s');
path.scope.parent.push({
id: sigCallID,
init: t.callExpression(refreshSig, [])
}); // The signature call is split in two parts. One part is called inside the function.
// This is used to signal when first render happens.
if (path.node.body.type !== 'BlockStatement') {
path.node.body = t.blockStatement([t.returnStatement(path.node.body)]);
}
path.get('body').unshiftContainer('body', t.expressionStatement(t.callExpression(sigCallID, []))); // The second call is around the function itself.
// This is used to associate a type with a signature.
if (path.parent.type === 'VariableDeclarator') {
var insertAfterPath = null;
path.find(function (p) {
if (p.parentPath.isBlock()) {
insertAfterPath = p;
return true;
Program: {
enter: function (path) {
path.traverse(HookCallsVisitor);
},
exit: function (path) {
var registrations = registrationsByProgramPath.get(path);
if (void 0 !== registrations) {
var node = path.node;
if (!seenForOutro.has(node)) {
seenForOutro.add(node);
registrationsByProgramPath.delete(path);
var declarators = [];
path.pushContainer(
"body",
t.variableDeclaration("var", declarators)
);
registrations.forEach(function (_ref) {
var handle = _ref.handle;
path.pushContainer(
"body",
t.expressionStatement(
t.callExpression(refreshReg, [
handle,
t.stringLiteral(_ref.persistentID)
])
)
);
declarators.push(t.variableDeclarator(handle));
});
}
});
if (insertAfterPath === null) {
return;
} // Special case when a function would get an inferred name:
// let Foo = () => {}
// let Foo = function() {}
// We'll add signature it on next line so that
// we don't mess up the inferred 'Foo' function name.
insertAfterPath.insertAfter(t.expressionStatement(t.callExpression(sigCallID, createArgumentsForSignature(path.parent.id, signature, insertAfterPath.scope)))); // Result: let Foo = () => {}; __signature(Foo, ...);
} else {
// let Foo = hoc(() => {})
var paths = [path].concat(findHOCCallPathsAbove(path));
paths.forEach(function (p) {
p.replaceWith(t.callExpression(sigCallID, createArgumentsForSignature(p.node, signature, p.scope)));
}); // Result: let Foo = __signature(hoc(__signature(() => {}, ...)), ...)
}
}
},
VariableDeclaration: function (path) {
var node = path.node;
var programPath;
var insertAfterPath;
var modulePrefix = '';
switch (path.parent.type) {
case 'Program':
insertAfterPath = path;
programPath = path.parentPath;
break;
case 'TSModuleBlock':
insertAfterPath = path;
programPath = insertAfterPath.parentPath.parentPath;
break;
case 'ExportNamedDeclaration':
insertAfterPath = path.parentPath;
programPath = insertAfterPath.parentPath;
break;
case 'ExportDefaultDeclaration':
insertAfterPath = path.parentPath;
programPath = insertAfterPath.parentPath;
break;
default:
return;
} // These types can be nested in typescript namespace
// We need to find the export chain
// Or return if it stays local
if (path.parent.type === 'TSModuleBlock' || path.parent.type === 'ExportNamedDeclaration') {
while (programPath.type !== 'Program') {
if (programPath.type === 'TSModuleDeclaration') {
if (programPath.parentPath.type !== 'Program' && programPath.parentPath.type !== 'ExportNamedDeclaration') {
return;
}
modulePrefix = programPath.node.id.name + '$' + modulePrefix;
}
programPath = programPath.parentPath;
}
} // Make sure we're not mutating the same tree twice.
// This can happen if another Babel plugin replaces parents.
if (seenForRegistration.has(node)) {
return;
}
seenForRegistration.add(node); // Don't mutate the tree above this point.
var declPaths = path.get('declarations');
if (declPaths.length !== 1) {
return;
}
var declPath = declPaths[0];
var inferredName = declPath.node.id.name;
var innerName = modulePrefix + inferredName;
findInnerComponents(innerName, declPath, function (persistentID, targetExpr, targetPath) {
if (targetPath === null) {
// For case like:
// export const Something = hoc(Foo)
// we don't want to wrap Foo inside the call.
// Instead we assume it's registered at definition.
return;
}
var handle = createRegistration(programPath, persistentID);
if (targetPath.parent.type === 'VariableDeclarator') {
// Special case when a variable would get an inferred name:
// let Foo = () => {}
// let Foo = function() {}
// let Foo = styled.div``;
// We'll register it on next line so that
// we don't mess up the inferred 'Foo' function name.
// (eg: with @babel/plugin-transform-react-display-name or
// babel-plugin-styled-components)
insertAfterPath.insertAfter(t.expressionStatement(t.assignmentExpression('=', handle, declPath.node.id))); // Result: let Foo = () => {}; _c1 = Foo;
} else {
// let Foo = hoc(() => {})
targetPath.replaceWith(t.assignmentExpression('=', handle, targetExpr)); // Result: let Foo = hoc(_c1 = () => {})
}
});
},
Program: {
enter: function (path) {
// This is a separate early visitor because we need to collect Hook calls
// and "const [foo, setFoo] = ..." signatures before the destructuring
// transform mangles them. This extra traversal is not ideal for perf,
// but it's the best we can do until we stop transpiling destructuring.
path.traverse(HookCallsVisitor);
},
exit: function (path) {
var registrations = registrationsByProgramPath.get(path);
if (registrations === undefined) {
return;
} // Make sure we're not mutating the same tree twice.
// This can happen if another Babel plugin replaces parents.
var node = path.node;
if (seenForOutro.has(node)) {
return;
}
seenForOutro.add(node); // Don't mutate the tree above this point.
registrationsByProgramPath.delete(path);
var declarators = [];
path.pushContainer('body', t.variableDeclaration('var', declarators));
registrations.forEach(function (_ref) {
var handle = _ref.handle,
persistentID = _ref.persistentID;
path.pushContainer('body', t.expressionStatement(t.callExpression(refreshReg, [handle, t.stringLiteral(persistentID)])));
declarators.push(t.variableDeclarator(handle));
});
}
}
}
};
}
module.exports = ReactFreshBabelPlugin;
})();
}
};
});

1230

cjs/react-refresh-babel.production.js
/**
* @license React
* react-refresh-babel.production.min.js
* react-refresh-babel.production.js
*

@@ -11,845 +11,577 @@ * Copyright (c) Meta Platforms, Inc. and affiliates.

'use strict';
function ReactFreshBabelPlugin (babel) {
let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
if (typeof babel.env === 'function') {
// Only available in Babel 7.
const env = babel.env();
if (env !== 'development' && !opts.skipEnvCheck) {
throw new Error('React Refresh Babel transform should only be enabled in development environment. ' + 'Instead, the environment is: "' + env + '". If you want to override this check, pass {skipEnvCheck: true} as plugin options.');
}
}
const t = babel.types;
const refreshReg = t.identifier(opts.refreshReg || '$RefreshReg$');
const refreshSig = t.identifier(opts.refreshSig || '$RefreshSig$');
const registrationsByProgramPath = new Map();
"use strict";
module.exports = function (babel) {
function createRegistration(programPath, persistentID) {
const handle = programPath.scope.generateUidIdentifier('c');
if (!registrationsByProgramPath.has(programPath)) {
var handle = programPath.scope.generateUidIdentifier("c");
registrationsByProgramPath.has(programPath) ||
registrationsByProgramPath.set(programPath, []);
}
const registrations = registrationsByProgramPath.get(programPath);
registrations.push({
handle,
persistentID
});
registrationsByProgramPath
.get(programPath)
.push({ handle: handle, persistentID: persistentID });
return handle;
}
function isComponentishName(name) {
return typeof name === 'string' && name[0] >= 'A' && name[0] <= 'Z';
return "string" === typeof name && "A" <= name[0] && "Z" >= name[0];
}
function findInnerComponents(inferredName, path, callback) {
const node = path.node;
var node = path.node;
switch (node.type) {
case 'Identifier':
{
if (!isComponentishName(node.name)) {
return false;
} // export default hoc(Foo)
// const X = hoc(Foo)
callback(inferredName, node, null);
return true;
case "Identifier":
if (!isComponentishName(node.name)) break;
callback(inferredName, node, null);
return !0;
case "FunctionDeclaration":
return callback(inferredName, node.id, null), !0;
case "ArrowFunctionExpression":
if ("ArrowFunctionExpression" === node.body.type) break;
callback(inferredName, node, path);
return !0;
case "FunctionExpression":
return callback(inferredName, node, path), !0;
case "CallExpression":
var argsPath = path.get("arguments");
if (void 0 === argsPath || 0 === argsPath.length) break;
var calleePath = path.get("callee");
switch (calleePath.node.type) {
case "MemberExpression":
case "Identifier":
calleePath = calleePath.getSource();
if (
!findInnerComponents(
inferredName + "$" + calleePath,
argsPath[0],
callback
)
)
return !1;
callback(inferredName, node, path);
return !0;
default:
return !1;
}
case 'FunctionDeclaration':
{
// function Foo() {}
// export function Foo() {}
// export default function Foo() {}
callback(inferredName, node.id, null);
return true;
}
case 'ArrowFunctionExpression':
{
if (node.body.type === 'ArrowFunctionExpression') {
return false;
} // let Foo = () => {}
// export default hoc1(hoc2(() => {}))
callback(inferredName, node, path);
return true;
}
case 'FunctionExpression':
{
// let Foo = function() {}
// const Foo = hoc1(forwardRef(function renderFoo() {}))
// export default memo(function() {})
callback(inferredName, node, path);
return true;
}
case 'CallExpression':
{
const argsPath = path.get('arguments');
if (argsPath === undefined || argsPath.length === 0) {
return false;
}
const calleePath = path.get('callee');
switch (calleePath.node.type) {
case 'MemberExpression':
case 'Identifier':
{
const calleeSource = calleePath.getSource();
const firstArgPath = argsPath[0];
const innerName = inferredName + '$' + calleeSource;
const foundInside = findInnerComponents(innerName, firstArgPath, callback);
if (!foundInside) {
return false;
} // const Foo = hoc1(hoc2(() => {}))
// export default memo(React.forwardRef(function() {}))
callback(inferredName, node, path);
return true;
}
default:
{
return false;
}
}
}
case 'VariableDeclarator':
{
const init = node.init;
if (init === null) {
return false;
}
const name = node.id.name;
if (!isComponentishName(name)) {
return false;
}
switch (init.type) {
case 'ArrowFunctionExpression':
case 'FunctionExpression':
// Likely component definitions.
case "VariableDeclarator":
if (
((argsPath = node.init),
null !== argsPath &&
((calleePath = node.id.name), isComponentishName(calleePath)))
) {
switch (argsPath.type) {
case "ArrowFunctionExpression":
case "FunctionExpression":
break;
case 'CallExpression':
{
// Maybe a HOC.
// Try to determine if this is some form of import.
const callee = init.callee;
const calleeType = callee.type;
if (calleeType === 'Import') {
return false;
} else if (calleeType === 'Identifier') {
if (callee.name.indexOf('require') === 0) {
return false;
} else if (callee.name.indexOf('import') === 0) {
return false;
} // Neither require nor import. Might be a HOC.
// Pass through.
} else ;
break;
}
case 'TaggedTemplateExpression':
// Maybe something like styled.div`...`
case "CallExpression":
node = argsPath.callee;
var calleeType = node.type;
if (
"Import" === calleeType ||
("Identifier" === calleeType &&
(0 === node.name.indexOf("require") ||
0 === node.name.indexOf("import")))
)
return !1;
break;
case "TaggedTemplateExpression":
break;
default:
return false;
return !1;
}
const initPath = path.get('init');
const foundInside = findInnerComponents(inferredName, initPath, callback);
if (foundInside) {
return true;
} // See if this identifier is used in JSX. Then it's a component.
const binding = path.scope.getBinding(name);
if (binding === undefined) {
return;
}
let isLikelyUsedAsType = false;
const referencePaths = binding.referencePaths;
for (let i = 0; i < referencePaths.length; i++) {
const ref = referencePaths[i];
if (ref.node && ref.node.type !== 'JSXIdentifier' && ref.node.type !== 'Identifier') {
continue;
}
const refParent = ref.parent;
if (refParent.type === 'JSXOpeningElement') {
isLikelyUsedAsType = true;
} else if (refParent.type === 'CallExpression') {
const callee = refParent.callee;
let fnName;
switch (callee.type) {
case 'Identifier':
fnName = callee.name;
break;
case 'MemberExpression':
fnName = callee.property.name;
break;
node = path.get("init");
if (findInnerComponents(inferredName, node, callback)) return !0;
calleePath = path.scope.getBinding(calleePath);
if (void 0 === calleePath) return;
path = !1;
calleePath = calleePath.referencePaths;
for (calleeType = 0; calleeType < calleePath.length; calleeType++) {
var ref = calleePath[calleeType];
if (
!ref.node ||
"JSXIdentifier" === ref.node.type ||
"Identifier" === ref.node.type
) {
ref = ref.parent;
if ("JSXOpeningElement" === ref.type) path = !0;
else if ("CallExpression" === ref.type) {
ref = ref.callee;
var fnName = void 0;
switch (ref.type) {
case "Identifier":
fnName = ref.name;
break;
case "MemberExpression":
fnName = ref.property.name;
}
switch (fnName) {
case "createElement":
case "jsx":
case "jsxDEV":
case "jsxs":
path = !0;
}
}
switch (fnName) {
case 'createElement':
case 'jsx':
case 'jsxDEV':
case 'jsxs':
isLikelyUsedAsType = true;
break;
}
if (path) return callback(inferredName, argsPath, node), !0;
}
if (isLikelyUsedAsType) {
// const X = ... + later <X />
callback(inferredName, init, initPath);
return true;
}
}
}
}
return false;
return !1;
}
function isBuiltinHook(hookName) {
switch (hookName) {
case 'useState':
case 'React.useState':
case 'useReducer':
case 'React.useReducer':
case 'useEffect':
case 'React.useEffect':
case 'useLayoutEffect':
case 'React.useLayoutEffect':
case 'useMemo':
case 'React.useMemo':
case 'useCallback':
case 'React.useCallback':
case 'useRef':
case 'React.useRef':
case 'useContext':
case 'React.useContext':
case 'useImperativeHandle':
case 'React.useImperativeHandle':
case 'useDebugValue':
case 'React.useDebugValue':
case 'useId':
case 'React.useId':
case 'useDeferredValue':
case 'React.useDeferredValue':
case 'useTransition':
case 'React.useTransition':
case 'useInsertionEffect':
case 'React.useInsertionEffect':
case 'useSyncExternalStore':
case 'React.useSyncExternalStore':
case 'useFormStatus':
case 'React.useFormStatus':
case 'useFormState':
case 'React.useFormState':
case 'useOptimistic':
case 'React.useOptimistic':
return true;
default:
return false;
}
}
function getHookCallsSignature(functionNode) {
const fnHookCalls = hookCalls.get(functionNode);
if (fnHookCalls === undefined) {
return null;
}
return {
key: fnHookCalls.map(call => call.name + '{' + call.key + '}').join('\n'),
customHooks: fnHookCalls.filter(call => !isBuiltinHook(call.name)).map(call => t.cloneDeep(call.callee))
};
functionNode = hookCalls.get(functionNode);
return void 0 === functionNode
? null
: {
key: functionNode
.map(function (call) {
return call.name + "{" + call.key + "}";
})
.join("\n"),
customHooks: functionNode
.filter(function (call) {
a: switch (call.name) {
case "useState":
case "React.useState":
case "useReducer":
case "React.useReducer":
case "useEffect":
case "React.useEffect":
case "useLayoutEffect":
case "React.useLayoutEffect":
case "useMemo":
case "React.useMemo":
case "useCallback":
case "React.useCallback":
case "useRef":
case "React.useRef":
case "useContext":
case "React.useContext":
case "useImperativeHandle":
case "React.useImperativeHandle":
case "useDebugValue":
case "React.useDebugValue":
case "useId":
case "React.useId":
case "useDeferredValue":
case "React.useDeferredValue":
case "useTransition":
case "React.useTransition":
case "useInsertionEffect":
case "React.useInsertionEffect":
case "useSyncExternalStore":
case "React.useSyncExternalStore":
case "useFormStatus":
case "React.useFormStatus":
case "useFormState":
case "React.useFormState":
case "useActionState":
case "React.useActionState":
case "useOptimistic":
case "React.useOptimistic":
call = !0;
break a;
default:
call = !1;
}
return !call;
})
.map(function (call) {
return t.cloneDeep(call.callee);
})
};
}
const hasForceResetCommentByFile = new WeakMap(); // We let user do /* @refresh reset */ to reset state in the whole file.
function hasForceResetComment(path) {
const file = path.hub.file;
let hasForceReset = hasForceResetCommentByFile.get(file);
if (hasForceReset !== undefined) {
return hasForceReset;
}
hasForceReset = false;
const comments = file.ast.comments;
for (let i = 0; i < comments.length; i++) {
const cmt = comments[i];
if (cmt.value.indexOf('@refresh reset') !== -1) {
hasForceReset = true;
path = path.hub.file;
var hasForceReset = hasForceResetCommentByFile.get(path);
if (void 0 !== hasForceReset) return hasForceReset;
hasForceReset = !1;
for (var comments = path.ast.comments, i = 0; i < comments.length; i++)
if (-1 !== comments[i].value.indexOf("@refresh reset")) {
hasForceReset = !0;
break;
}
}
hasForceResetCommentByFile.set(file, hasForceReset);
hasForceResetCommentByFile.set(path, hasForceReset);
return hasForceReset;
}
function createArgumentsForSignature(node, signature, scope) {
const key = signature.key,
customHooks = signature.customHooks;
let forceReset = hasForceResetComment(scope.path);
const customHooksInScope = [];
customHooks.forEach(callee => {
// Check if a corresponding binding exists where we emit the signature.
let bindingName;
var key = signature.key;
signature = signature.customHooks;
var forceReset = hasForceResetComment(scope.path),
customHooksInScope = [];
signature.forEach(function (callee) {
switch (callee.type) {
case 'MemberExpression':
if (callee.object.type === 'Identifier') {
bindingName = callee.object.name;
}
case "MemberExpression":
if ("Identifier" === callee.object.type)
var bindingName = callee.object.name;
break;
case 'Identifier':
case "Identifier":
bindingName = callee.name;
break;
}
if (scope.hasBinding(bindingName)) {
customHooksInScope.push(callee);
} else {
// We don't have anything to put in the array because Hook is out of scope.
// Since it could potentially have been edited, remount the component.
forceReset = true;
}
scope.hasBinding(bindingName)
? customHooksInScope.push(callee)
: (forceReset = !0);
});
let finalKey = key;
if (typeof require === 'function' && !opts.emitFullSignatures) {
// Prefer to hash when we can (e.g. outside of ASTExplorer).
// This makes it deterministically compact, even if there's
// e.g. a useState initializer with some code inside.
// We also need it for www that has transforms like cx()
// that don't understand if something is part of a string.
finalKey = require('crypto').createHash('sha1').update(key).digest('base64');
}
const args = [node, t.stringLiteral(finalKey)];
if (forceReset || customHooksInScope.length > 0) {
args.push(t.booleanLiteral(forceReset));
}
if (customHooksInScope.length > 0) {
args.push( // TODO: We could use an arrow here to be more compact.
// However, don't do it until AMA can run them natively.
t.functionExpression(null, [], t.blockStatement([t.returnStatement(t.arrayExpression(customHooksInScope))])));
}
return args;
signature = key;
"function" !== typeof require ||
opts.emitFullSignatures ||
(signature = require("crypto")
.createHash("sha1")
.update(key)
.digest("base64"));
node = [node, t.stringLiteral(signature)];
(forceReset || 0 < customHooksInScope.length) &&
node.push(t.booleanLiteral(forceReset));
0 < customHooksInScope.length &&
node.push(
t.functionExpression(
null,
[],
t.blockStatement([
t.returnStatement(t.arrayExpression(customHooksInScope))
])
)
);
return node;
}
function findHOCCallPathsAbove(path) {
const calls = [];
while (true) {
if (!path) {
return calls;
}
const parentPath = path.parentPath;
if (!parentPath) {
return calls;
}
if ( // hoc(_c = function() { })
parentPath.node.type === 'AssignmentExpression' && path.node === parentPath.node.right) {
// Ignore registrations.
for (var calls = []; ; ) {
if (!path) return calls;
var parentPath = path.parentPath;
if (!parentPath) return calls;
if (
"AssignmentExpression" === parentPath.node.type &&
path.node === parentPath.node.right
)
path = parentPath;
continue;
}
if ( // hoc1(hoc2(...))
parentPath.node.type === 'CallExpression' && path.node !== parentPath.node.callee) {
calls.push(parentPath);
path = parentPath;
continue;
}
return calls; // Stop at other types.
else if (
"CallExpression" === parentPath.node.type &&
path.node !== parentPath.node.callee
)
calls.push(parentPath), (path = parentPath);
else return calls;
}
}
const seenForRegistration = new WeakSet();
const seenForSignature = new WeakSet();
const seenForOutro = new WeakSet();
const hookCalls = new WeakMap();
const HookCallsVisitor = {
CallExpression(path) {
const node = path.node;
const callee = node.callee; // Note: this visitor MUST NOT mutate the tree in any way.
// It runs early in a separate traversal and should be very fast.
let name = null;
switch (callee.type) {
case 'Identifier':
name = callee.name;
break;
case 'MemberExpression':
name = callee.property.name;
break;
var opts =
1 < arguments.length && void 0 !== arguments[1] ? arguments[1] : {};
if ("function" === typeof babel.env) {
var env = babel.env();
if ("development" !== env && !opts.skipEnvCheck)
throw Error(
'React Refresh Babel transform should only be enabled in development environment. Instead, the environment is: "' +
env +
'". If you want to override this check, pass {skipEnvCheck: true} as plugin options.'
);
}
var t = babel.types,
refreshReg = t.identifier(opts.refreshReg || "$RefreshReg$"),
refreshSig = t.identifier(opts.refreshSig || "$RefreshSig$"),
registrationsByProgramPath = new Map(),
hasForceResetCommentByFile = new WeakMap(),
seenForRegistration = new WeakSet(),
seenForSignature = new WeakSet(),
seenForOutro = new WeakSet(),
hookCalls = new WeakMap(),
HookCallsVisitor = {
CallExpression: function (path) {
var callee = path.node.callee,
name = null;
switch (callee.type) {
case "Identifier":
name = callee.name;
break;
case "MemberExpression":
name = callee.property.name;
}
if (
null !== name &&
/^use[A-Z]/.test(name) &&
((callee = path.scope.getFunctionParent()), null !== callee)
) {
callee = callee.block;
hookCalls.has(callee) || hookCalls.set(callee, []);
callee = hookCalls.get(callee);
var key = "";
"VariableDeclarator" === path.parent.type &&
(key = path.parentPath.get("id").getSource());
var args = path.get("arguments");
"useState" === name && 0 < args.length
? (key += "(" + args[0].getSource() + ")")
: "useReducer" === name &&
1 < args.length &&
(key += "(" + args[1].getSource() + ")");
callee.push({ callee: path.node.callee, name: name, key: key });
}
}
if (name === null || !/^use[A-Z]/.test(name)) {
return;
}
const fnScope = path.scope.getFunctionParent();
if (fnScope === null) {
return;
} // This is a Hook call. Record it.
const fnNode = fnScope.block;
if (!hookCalls.has(fnNode)) {
hookCalls.set(fnNode, []);
}
const hookCallsForFn = hookCalls.get(fnNode);
let key = '';
if (path.parent.type === 'VariableDeclarator') {
// TODO: if there is no LHS, consider some other heuristic.
key = path.parentPath.get('id').getSource();
} // Some built-in Hooks reset on edits to arguments.
const args = path.get('arguments');
if (name === 'useState' && args.length > 0) {
// useState second argument is initial state.
key += '(' + args[0].getSource() + ')';
} else if (name === 'useReducer' && args.length > 1) {
// useReducer second argument is initial state.
key += '(' + args[1].getSource() + ')';
}
hookCallsForFn.push({
callee: path.node.callee,
name,
key
});
}
};
};
return {
visitor: {
ExportDefaultDeclaration(path) {
const node = path.node;
const decl = node.declaration;
const declPath = path.get('declaration');
if (decl.type !== 'CallExpression') {
// For now, we only support possible HOC calls here.
// Named function declarations are handled in FunctionDeclaration.
// Anonymous direct exports like export default function() {}
// are currently ignored.
return;
} // Make sure we're not mutating the same tree twice.
// This can happen if another Babel plugin replaces parents.
if (seenForRegistration.has(node)) {
return;
ExportDefaultDeclaration: function (path) {
var node = path.node,
decl = node.declaration,
declPath = path.get("declaration");
if ("CallExpression" === decl.type && !seenForRegistration.has(node)) {
seenForRegistration.add(node);
var programPath = path.parentPath;
findInnerComponents(
"%default%",
declPath,
function (persistentID, targetExpr, targetPath) {
null !== targetPath &&
((persistentID = createRegistration(programPath, persistentID)),
targetPath.replaceWith(
t.assignmentExpression("=", persistentID, targetExpr)
));
}
);
}
seenForRegistration.add(node); // Don't mutate the tree above this point.
// This code path handles nested cases like:
// export default memo(() => {})
// In those cases it is more plausible people will omit names
// so they're worth handling despite possible false positives.
// More importantly, it handles the named case:
// export default memo(function Named() {})
const inferredName = '%default%';
const programPath = path.parentPath;
findInnerComponents(inferredName, declPath, (persistentID, targetExpr, targetPath) => {
if (targetPath === null) {
// For case like:
// export default hoc(Foo)
// we don't want to wrap Foo inside the call.
// Instead we assume it's registered at definition.
return;
}
const handle = createRegistration(programPath, persistentID);
targetPath.replaceWith(t.assignmentExpression('=', handle, targetExpr));
});
},
FunctionDeclaration: {
enter(path) {
const node = path.node;
let programPath;
let insertAfterPath;
let modulePrefix = '';
enter: function (path) {
var node = path.node,
modulePrefix = "";
switch (path.parent.type) {
case 'Program':
insertAfterPath = path;
programPath = path.parentPath;
case "Program":
var insertAfterPath = path;
var programPath = path.parentPath;
break;
case 'TSModuleBlock':
case "TSModuleBlock":
insertAfterPath = path;
programPath = insertAfterPath.parentPath.parentPath;
break;
case 'ExportNamedDeclaration':
case "ExportNamedDeclaration":
insertAfterPath = path.parentPath;
programPath = insertAfterPath.parentPath;
break;
case 'ExportDefaultDeclaration':
case "ExportDefaultDeclaration":
insertAfterPath = path.parentPath;
programPath = insertAfterPath.parentPath;
break;
default:
return;
} // These types can be nested in typescript namespace
// We need to find the export chain
// Or return if it stays local
if (path.parent.type === 'TSModuleBlock' || path.parent.type === 'ExportNamedDeclaration') {
while (programPath.type !== 'Program') {
if (programPath.type === 'TSModuleDeclaration') {
if (programPath.parentPath.type !== 'Program' && programPath.parentPath.type !== 'ExportNamedDeclaration') {
}
if (
"TSModuleBlock" === path.parent.type ||
"ExportNamedDeclaration" === path.parent.type
)
for (; "Program" !== programPath.type; ) {
if ("TSModuleDeclaration" === programPath.type) {
if (
"Program" !== programPath.parentPath.type &&
"ExportNamedDeclaration" !== programPath.parentPath.type
)
return;
}
modulePrefix = programPath.node.id.name + '$' + modulePrefix;
modulePrefix = programPath.node.id.name + "$" + modulePrefix;
}
programPath = programPath.parentPath;
}
}
const id = node.id;
if (id === null) {
// We don't currently handle anonymous default exports.
return;
}
const inferredName = id.name;
if (!isComponentishName(inferredName)) {
return;
} // Make sure we're not mutating the same tree twice.
// This can happen if another Babel plugin replaces parents.
if (seenForRegistration.has(node)) {
return;
}
seenForRegistration.add(node); // Don't mutate the tree above this point.
const innerName = modulePrefix + inferredName; // export function Named() {}
// function Named() {}
findInnerComponents(innerName, path, (persistentID, targetExpr) => {
const handle = createRegistration(programPath, persistentID);
insertAfterPath.insertAfter(t.expressionStatement(t.assignmentExpression('=', handle, targetExpr)));
});
var id = node.id;
null !== id &&
((id = id.name),
isComponentishName(id) &&
!seenForRegistration.has(node) &&
(seenForRegistration.add(node),
findInnerComponents(
modulePrefix + id,
path,
function (persistentID, targetExpr) {
persistentID = createRegistration(programPath, persistentID);
insertAfterPath.insertAfter(
t.expressionStatement(
t.assignmentExpression("=", persistentID, targetExpr)
)
);
}
)));
},
exit(path) {
const node = path.node;
const id = node.id;
if (id === null) {
return;
}
const signature = getHookCallsSignature(node);
if (signature === null) {
return;
} // Make sure we're not mutating the same tree twice.
// This can happen if another Babel plugin replaces parents.
if (seenForSignature.has(node)) {
return;
}
seenForSignature.add(node); // Don't mutate the tree above this point.
const sigCallID = path.scope.generateUidIdentifier('_s');
path.scope.parent.push({
id: sigCallID,
init: t.callExpression(refreshSig, [])
}); // The signature call is split in two parts. One part is called inside the function.
// This is used to signal when first render happens.
path.get('body').unshiftContainer('body', t.expressionStatement(t.callExpression(sigCallID, []))); // The second call is around the function itself.
// This is used to associate a type with a signature.
// Unlike with $RefreshReg$, this needs to work for nested
// declarations too. So we need to search for a path where
// we can insert a statement rather than hard coding it.
let insertAfterPath = null;
path.find(p => {
if (p.parentPath.isBlock()) {
insertAfterPath = p;
return true;
exit: function (path) {
var node = path.node,
id = node.id;
if (null !== id) {
var signature = getHookCallsSignature(node);
if (null !== signature && !seenForSignature.has(node)) {
seenForSignature.add(node);
node = path.scope.generateUidIdentifier("_s");
path.scope.parent.push({
id: node,
init: t.callExpression(refreshSig, [])
});
path
.get("body")
.unshiftContainer(
"body",
t.expressionStatement(t.callExpression(node, []))
);
var insertAfterPath = null;
path.find(function (p) {
if (p.parentPath.isBlock()) return (insertAfterPath = p), !0;
});
null !== insertAfterPath &&
insertAfterPath.insertAfter(
t.expressionStatement(
t.callExpression(
node,
createArgumentsForSignature(
id,
signature,
insertAfterPath.scope
)
)
)
);
}
});
if (insertAfterPath === null) {
return;
}
insertAfterPath.insertAfter(t.expressionStatement(t.callExpression(sigCallID, createArgumentsForSignature(id, signature, insertAfterPath.scope))));
}
},
'ArrowFunctionExpression|FunctionExpression': {
exit(path) {
const node = path.node;
const signature = getHookCallsSignature(node);
if (signature === null) {
return;
} // Make sure we're not mutating the same tree twice.
// This can happen if another Babel plugin replaces parents.
if (seenForSignature.has(node)) {
return;
}
seenForSignature.add(node); // Don't mutate the tree above this point.
const sigCallID = path.scope.generateUidIdentifier('_s');
path.scope.parent.push({
id: sigCallID,
init: t.callExpression(refreshSig, [])
}); // The signature call is split in two parts. One part is called inside the function.
// This is used to signal when first render happens.
if (path.node.body.type !== 'BlockStatement') {
path.node.body = t.blockStatement([t.returnStatement(path.node.body)]);
}
path.get('body').unshiftContainer('body', t.expressionStatement(t.callExpression(sigCallID, []))); // The second call is around the function itself.
// This is used to associate a type with a signature.
if (path.parent.type === 'VariableDeclarator') {
let insertAfterPath = null;
path.find(p => {
if (p.parentPath.isBlock()) {
insertAfterPath = p;
return true;
}
"ArrowFunctionExpression|FunctionExpression": {
exit: function (path) {
var node = path.node,
signature = getHookCallsSignature(node);
if (null !== signature && !seenForSignature.has(node)) {
seenForSignature.add(node);
var sigCallID = path.scope.generateUidIdentifier("_s");
path.scope.parent.push({
id: sigCallID,
init: t.callExpression(refreshSig, [])
});
if (insertAfterPath === null) {
return;
} // Special case when a function would get an inferred name:
// let Foo = () => {}
// let Foo = function() {}
// We'll add signature it on next line so that
// we don't mess up the inferred 'Foo' function name.
insertAfterPath.insertAfter(t.expressionStatement(t.callExpression(sigCallID, createArgumentsForSignature(path.parent.id, signature, insertAfterPath.scope)))); // Result: let Foo = () => {}; __signature(Foo, ...);
} else {
// let Foo = hoc(() => {})
const paths = [path].concat(findHOCCallPathsAbove(path));
paths.forEach(p => {
p.replaceWith(t.callExpression(sigCallID, createArgumentsForSignature(p.node, signature, p.scope)));
}); // Result: let Foo = __signature(hoc(__signature(() => {}, ...)), ...)
"BlockStatement" !== path.node.body.type &&
(path.node.body = t.blockStatement([
t.returnStatement(path.node.body)
]));
path
.get("body")
.unshiftContainer(
"body",
t.expressionStatement(t.callExpression(sigCallID, []))
);
if ("VariableDeclarator" === path.parent.type) {
var insertAfterPath = null;
path.find(function (p) {
if (p.parentPath.isBlock()) return (insertAfterPath = p), !0;
});
null !== insertAfterPath &&
insertAfterPath.insertAfter(
t.expressionStatement(
t.callExpression(
sigCallID,
createArgumentsForSignature(
path.parent.id,
signature,
insertAfterPath.scope
)
)
)
);
} else
[path].concat(findHOCCallPathsAbove(path)).forEach(function (p) {
p.replaceWith(
t.callExpression(
sigCallID,
createArgumentsForSignature(p.node, signature, p.scope)
)
);
});
}
}
},
VariableDeclaration(path) {
const node = path.node;
let programPath;
let insertAfterPath;
let modulePrefix = '';
VariableDeclaration: function (path) {
var node = path.node,
modulePrefix = "";
switch (path.parent.type) {
case 'Program':
insertAfterPath = path;
programPath = path.parentPath;
case "Program":
var insertAfterPath = path;
var programPath = path.parentPath;
break;
case 'TSModuleBlock':
case "TSModuleBlock":
insertAfterPath = path;
programPath = insertAfterPath.parentPath.parentPath;
break;
case 'ExportNamedDeclaration':
case "ExportNamedDeclaration":
insertAfterPath = path.parentPath;
programPath = insertAfterPath.parentPath;
break;
case 'ExportDefaultDeclaration':
case "ExportDefaultDeclaration":
insertAfterPath = path.parentPath;
programPath = insertAfterPath.parentPath;
break;
default:
return;
} // These types can be nested in typescript namespace
// We need to find the export chain
// Or return if it stays local
if (path.parent.type === 'TSModuleBlock' || path.parent.type === 'ExportNamedDeclaration') {
while (programPath.type !== 'Program') {
if (programPath.type === 'TSModuleDeclaration') {
if (programPath.parentPath.type !== 'Program' && programPath.parentPath.type !== 'ExportNamedDeclaration') {
}
if (
"TSModuleBlock" === path.parent.type ||
"ExportNamedDeclaration" === path.parent.type
)
for (; "Program" !== programPath.type; ) {
if ("TSModuleDeclaration" === programPath.type) {
if (
"Program" !== programPath.parentPath.type &&
"ExportNamedDeclaration" !== programPath.parentPath.type
)
return;
}
modulePrefix = programPath.node.id.name + '$' + modulePrefix;
modulePrefix = programPath.node.id.name + "$" + modulePrefix;
}
programPath = programPath.parentPath;
}
} // Make sure we're not mutating the same tree twice.
// This can happen if another Babel plugin replaces parents.
if (seenForRegistration.has(node)) {
return;
if (
!seenForRegistration.has(node) &&
(seenForRegistration.add(node),
(path = path.get("declarations")),
1 === path.length)
) {
var declPath = path[0];
findInnerComponents(
modulePrefix + declPath.node.id.name,
declPath,
function (persistentID, targetExpr, targetPath) {
null !== targetPath &&
((persistentID = createRegistration(programPath, persistentID)),
"VariableDeclarator" === targetPath.parent.type
? insertAfterPath.insertAfter(
t.expressionStatement(
t.assignmentExpression(
"=",
persistentID,
declPath.node.id
)
)
)
: targetPath.replaceWith(
t.assignmentExpression("=", persistentID, targetExpr)
));
}
);
}
seenForRegistration.add(node); // Don't mutate the tree above this point.
const declPaths = path.get('declarations');
if (declPaths.length !== 1) {
return;
}
const declPath = declPaths[0];
const inferredName = declPath.node.id.name;
const innerName = modulePrefix + inferredName;
findInnerComponents(innerName, declPath, (persistentID, targetExpr, targetPath) => {
if (targetPath === null) {
// For case like:
// export const Something = hoc(Foo)
// we don't want to wrap Foo inside the call.
// Instead we assume it's registered at definition.
return;
}
const handle = createRegistration(programPath, persistentID);
if (targetPath.parent.type === 'VariableDeclarator') {
// Special case when a variable would get an inferred name:
// let Foo = () => {}
// let Foo = function() {}
// let Foo = styled.div``;
// We'll register it on next line so that
// we don't mess up the inferred 'Foo' function name.
// (eg: with @babel/plugin-transform-react-display-name or
// babel-plugin-styled-components)
insertAfterPath.insertAfter(t.expressionStatement(t.assignmentExpression('=', handle, declPath.node.id))); // Result: let Foo = () => {}; _c1 = Foo;
} else {
// let Foo = hoc(() => {})
targetPath.replaceWith(t.assignmentExpression('=', handle, targetExpr)); // Result: let Foo = hoc(_c1 = () => {})
}
});
},
Program: {
enter(path) {
// This is a separate early visitor because we need to collect Hook calls
// and "const [foo, setFoo] = ..." signatures before the destructuring
// transform mangles them. This extra traversal is not ideal for perf,
// but it's the best we can do until we stop transpiling destructuring.
enter: function (path) {
path.traverse(HookCallsVisitor);
},
exit(path) {
const registrations = registrationsByProgramPath.get(path);
if (registrations === undefined) {
return;
} // Make sure we're not mutating the same tree twice.
// This can happen if another Babel plugin replaces parents.
const node = path.node;
if (seenForOutro.has(node)) {
return;
exit: function (path) {
var registrations = registrationsByProgramPath.get(path);
if (void 0 !== registrations) {
var node = path.node;
if (!seenForOutro.has(node)) {
seenForOutro.add(node);
registrationsByProgramPath.delete(path);
var declarators = [];
path.pushContainer(
"body",
t.variableDeclaration("var", declarators)
);
registrations.forEach(function (_ref) {
var handle = _ref.handle;
path.pushContainer(
"body",
t.expressionStatement(
t.callExpression(refreshReg, [
handle,
t.stringLiteral(_ref.persistentID)
])
)
);
declarators.push(t.variableDeclarator(handle));
});
}
}
seenForOutro.add(node); // Don't mutate the tree above this point.
registrationsByProgramPath.delete(path);
const declarators = [];
path.pushContainer('body', t.variableDeclaration('var', declarators));
registrations.forEach((_ref) => {
let handle = _ref.handle,
persistentID = _ref.persistentID;
path.pushContainer('body', t.expressionStatement(t.callExpression(refreshReg, [handle, t.stringLiteral(persistentID)])));
declarators.push(t.variableDeclarator(handle));
});
}
}
}
};
}
module.exports = ReactFreshBabelPlugin;
};

943

cjs/react-refresh-runtime.development.js

@@ -11,646 +11,345 @@ /**

'use strict';
if (process.env.NODE_ENV !== "production") {
(function() {
'use strict';
// ATTENTION
var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
var REACT_MEMO_TYPE = Symbol.for('react.memo');
var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map; // We never remove these associations.
// It's OK to reference families, but use WeakMap/Set for types.
var allFamiliesByID = new Map();
var allFamiliesByType = new PossiblyWeakMap();
var allSignaturesByType = new PossiblyWeakMap(); // This WeakMap is read by React, so we only put families
// that have actually been edited here. This keeps checks fast.
var updatedFamiliesByType = new PossiblyWeakMap(); // This is cleared on every performReactRefresh() call.
// It is an array of [Family, NextType] tuples.
var pendingUpdates = []; // This is injected by the renderer via DevTools global hook.
var helpersByRendererID = new Map();
var helpersByRoot = new Map(); // We keep track of mounted roots so we can schedule updates.
var mountedRoots = new Set(); // If a root captures an error, we remember it so we can retry on edit.
var failedRoots = new Set(); // In environments that support WeakMap, we also remember the last element for every root.
// It needs to be weak because we do this even for roots that failed to mount.
// If there is no WeakMap, we won't attempt to do retrying.
var rootElements = typeof WeakMap === 'function' ? new WeakMap() : null;
var isPerformingRefresh = false;
function computeFullKey(signature) {
if (signature.fullKey !== null) {
return signature.fullKey;
}
var fullKey = signature.ownKey;
var hooks;
try {
hooks = signature.getCustomHooks();
} catch (err) {
// This can happen in an edge case, e.g. if expression like Foo.useSomething
// depends on Foo which is lazily initialized during rendering.
// In that case just assume we'll have to remount.
signature.forceReset = true;
signature.fullKey = fullKey;
return fullKey;
}
for (var i = 0; i < hooks.length; i++) {
var hook = hooks[i];
if (typeof hook !== 'function') {
// Something's wrong. Assume we need to remount.
signature.forceReset = true;
signature.fullKey = fullKey;
return fullKey;
}
var nestedHookSignature = allSignaturesByType.get(hook);
if (nestedHookSignature === undefined) {
// No signature means Hook wasn't in the source code, e.g. in a library.
// We'll skip it because we can assume it won't change during this session.
continue;
}
var nestedHookKey = computeFullKey(nestedHookSignature);
if (nestedHookSignature.forceReset) {
signature.forceReset = true;
}
fullKey += '\n---\n' + nestedHookKey;
}
signature.fullKey = fullKey;
return fullKey;
}
function haveEqualSignatures(prevType, nextType) {
var prevSignature = allSignaturesByType.get(prevType);
var nextSignature = allSignaturesByType.get(nextType);
if (prevSignature === undefined && nextSignature === undefined) {
return true;
}
if (prevSignature === undefined || nextSignature === undefined) {
return false;
}
if (computeFullKey(prevSignature) !== computeFullKey(nextSignature)) {
return false;
}
if (nextSignature.forceReset) {
return false;
}
return true;
}
function isReactClass(type) {
return type.prototype && type.prototype.isReactComponent;
}
function canPreserveStateBetween(prevType, nextType) {
if (isReactClass(prevType) || isReactClass(nextType)) {
return false;
}
if (haveEqualSignatures(prevType, nextType)) {
return true;
}
return false;
}
function resolveFamily(type) {
// Only check updated types to keep lookups fast.
return updatedFamiliesByType.get(type);
} // If we didn't care about IE11, we could use new Map/Set(iterable).
function cloneMap(map) {
var clone = new Map();
map.forEach(function (value, key) {
clone.set(key, value);
});
return clone;
}
function cloneSet(set) {
var clone = new Set();
set.forEach(function (value) {
clone.add(value);
});
return clone;
} // This is a safety mechanism to protect against rogue getters and Proxies.
function getProperty(object, property) {
try {
return object[property];
} catch (err) {
// Intentionally ignore.
return undefined;
}
}
function performReactRefresh() {
if (pendingUpdates.length === 0) {
return null;
}
if (isPerformingRefresh) {
return null;
}
isPerformingRefresh = true;
try {
var staleFamilies = new Set();
var updatedFamilies = new Set();
var updates = pendingUpdates;
pendingUpdates = [];
updates.forEach(function (_ref) {
var family = _ref[0],
nextType = _ref[1];
// Now that we got a real edit, we can create associations
// that will be read by the React reconciler.
var prevType = family.current;
updatedFamiliesByType.set(prevType, family);
updatedFamiliesByType.set(nextType, family);
family.current = nextType; // Determine whether this should be a re-render or a re-mount.
if (canPreserveStateBetween(prevType, nextType)) {
updatedFamilies.add(family);
} else {
staleFamilies.add(family);
}
}); // TODO: rename these fields to something more meaningful.
var update = {
updatedFamilies: updatedFamilies,
// Families that will re-render preserving state
staleFamilies: staleFamilies // Families that will be remounted
};
helpersByRendererID.forEach(function (helpers) {
// Even if there are no roots, set the handler on first update.
// This ensures that if *new* roots are mounted, they'll use the resolve handler.
helpers.setRefreshHandler(resolveFamily);
});
var didError = false;
var firstError = null; // We snapshot maps and sets that are mutated during commits.
// If we don't do this, there is a risk they will be mutated while
// we iterate over them. For example, trying to recover a failed root
// may cause another root to be added to the failed list -- an infinite loop.
var failedRootsSnapshot = cloneSet(failedRoots);
var mountedRootsSnapshot = cloneSet(mountedRoots);
var helpersByRootSnapshot = cloneMap(helpersByRoot);
failedRootsSnapshot.forEach(function (root) {
var helpers = helpersByRootSnapshot.get(root);
if (helpers === undefined) {
throw new Error('Could not find helpers for a root. This is a bug in React Refresh.');
}
if (!failedRoots.has(root)) {// No longer failed.
}
if (rootElements === null) {
return;
}
if (!rootElements.has(root)) {
return;
}
var element = rootElements.get(root);
"use strict";
"production" !== process.env.NODE_ENV &&
(function () {
function computeFullKey(signature) {
if (null !== signature.fullKey) return signature.fullKey;
var fullKey = signature.ownKey;
try {
helpers.scheduleRoot(root, element);
var hooks = signature.getCustomHooks();
} catch (err) {
if (!didError) {
didError = true;
firstError = err;
} // Keep trying other roots.
return (signature.forceReset = !0), (signature.fullKey = fullKey);
}
});
mountedRootsSnapshot.forEach(function (root) {
var helpers = helpersByRootSnapshot.get(root);
if (helpers === undefined) {
throw new Error('Could not find helpers for a root. This is a bug in React Refresh.');
for (var i = 0; i < hooks.length; i++) {
var hook = hooks[i];
if ("function" !== typeof hook)
return (signature.forceReset = !0), (signature.fullKey = fullKey);
hook = allSignaturesByType.get(hook);
if (void 0 !== hook) {
var nestedHookKey = computeFullKey(hook);
hook.forceReset && (signature.forceReset = !0);
fullKey += "\n---\n" + nestedHookKey;
}
}
if (!mountedRoots.has(root)) {// No longer mounted.
}
try {
helpers.scheduleRefresh(root, update);
} catch (err) {
if (!didError) {
didError = true;
firstError = err;
} // Keep trying other roots.
}
});
if (didError) {
throw firstError;
return (signature.fullKey = fullKey);
}
return update;
} finally {
isPerformingRefresh = false;
}
}
function register(type, id) {
{
if (type === null) {
return;
function resolveFamily(type) {
return updatedFamiliesByType.get(type);
}
if (typeof type !== 'function' && typeof type !== 'object') {
return;
} // This can happen in an edge case, e.g. if we register
// return value of a HOC but it returns a cached component.
// Ignore anything but the first registration for each type.
if (allFamiliesByType.has(type)) {
return;
} // Create family or remember to update it.
// None of this bookkeeping affects reconciliation
// until the first performReactRefresh() call above.
var family = allFamiliesByID.get(id);
if (family === undefined) {
family = {
current: type
};
allFamiliesByID.set(id, family);
} else {
pendingUpdates.push([family, type]);
function cloneMap(map) {
var clone = new Map();
map.forEach(function (value, key) {
clone.set(key, value);
});
return clone;
}
allFamiliesByType.set(type, family); // Visit inner types because we might not have registered them.
if (typeof type === 'object' && type !== null) {
switch (getProperty(type, '$$typeof')) {
case REACT_FORWARD_REF_TYPE:
register(type.render, id + '$render');
break;
case REACT_MEMO_TYPE:
register(type.type, id + '$type');
break;
}
}
}
}
function setSignature(type, key) {
var forceReset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
var getCustomHooks = arguments.length > 3 ? arguments[3] : undefined;
{
if (!allSignaturesByType.has(type)) {
allSignaturesByType.set(type, {
forceReset: forceReset,
ownKey: key,
fullKey: null,
getCustomHooks: getCustomHooks || function () {
return [];
}
function cloneSet(set) {
var clone = new Set();
set.forEach(function (value) {
clone.add(value);
});
} // Visit inner types because we might not have signed them.
if (typeof type === 'object' && type !== null) {
switch (getProperty(type, '$$typeof')) {
case REACT_FORWARD_REF_TYPE:
setSignature(type.render, key, forceReset, getCustomHooks);
break;
case REACT_MEMO_TYPE:
setSignature(type.type, key, forceReset, getCustomHooks);
break;
}
return clone;
}
}
} // This is lazily called during first render for a type.
// It captures Hook list at that time so inline requires don't break comparisons.
function collectCustomHooksForSignature(type) {
{
var signature = allSignaturesByType.get(type);
if (signature !== undefined) {
computeFullKey(signature);
function getProperty(object, property) {
try {
return object[property];
} catch (err) {}
}
}
}
function getFamilyByID(id) {
{
return allFamiliesByID.get(id);
}
}
function getFamilyByType(type) {
{
return allFamiliesByType.get(type);
}
}
function findAffectedHostInstances(families) {
{
var affectedInstances = new Set();
mountedRoots.forEach(function (root) {
var helpers = helpersByRoot.get(root);
if (helpers === undefined) {
throw new Error('Could not find helpers for a root. This is a bug in React Refresh.');
function register(type, id) {
if (
!(
null === type ||
("function" !== typeof type && "object" !== typeof type) ||
allFamiliesByType.has(type)
)
) {
var family = allFamiliesByID.get(id);
void 0 === family
? ((family = { current: type }), allFamiliesByID.set(id, family))
: pendingUpdates.push([family, type]);
allFamiliesByType.set(type, family);
if ("object" === typeof type && null !== type)
switch (getProperty(type, "$$typeof")) {
case REACT_FORWARD_REF_TYPE:
register(type.render, id + "$render");
break;
case REACT_MEMO_TYPE:
register(type.type, id + "$type");
}
}
var instancesForRoot = helpers.findHostInstancesForRefresh(root, families);
instancesForRoot.forEach(function (inst) {
affectedInstances.add(inst);
});
});
return affectedInstances;
}
}
function injectIntoGlobalHook(globalObject) {
{
// For React Native, the global hook will be set up by require('react-devtools-core').
// That code will run before us. So we need to monkeypatch functions on existing hook.
// For React Web, the global hook will be set up by the extension.
// This will also run before us.
var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;
if (hook === undefined) {
// However, if there is no DevTools extension, we'll need to set up the global hook ourselves.
// Note that in this case it's important that renderer code runs *after* this method call.
// Otherwise, the renderer will think that there is no global hook, and won't do the injection.
var nextID = 0;
globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
renderers: new Map(),
supportsFiber: true,
inject: function (injected) {
return nextID++;
},
onScheduleFiberRoot: function (id, root, children) {},
onCommitFiberRoot: function (id, root, maybePriorityLevel, didError) {},
onCommitFiberUnmount: function () {}
};
}
if (hook.isDisabled) {
// This isn't a real property on the hook, but it can be set to opt out
// of DevTools integration and associated warnings and logs.
// Using console['warn'] to evade Babel and ESLint
console['warn']('Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). ' + 'Fast Refresh is not compatible with this shim and will be disabled.');
return;
} // Here, we just want to get a reference to scheduleRefresh.
var oldInject = hook.inject;
hook.inject = function (injected) {
var id = oldInject.apply(this, arguments);
if (typeof injected.scheduleRefresh === 'function' && typeof injected.setRefreshHandler === 'function') {
// This version supports React Refresh.
helpersByRendererID.set(id, injected);
}
return id;
}; // Do the same for any already injected roots.
// This is useful if ReactDOM has already been initialized.
// https://github.com/facebook/react/issues/17626
hook.renderers.forEach(function (injected, id) {
if (typeof injected.scheduleRefresh === 'function' && typeof injected.setRefreshHandler === 'function') {
// This version supports React Refresh.
helpersByRendererID.set(id, injected);
}
}); // We also want to track currently mounted roots.
var oldOnCommitFiberRoot = hook.onCommitFiberRoot;
var oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function () {};
hook.onScheduleFiberRoot = function (id, root, children) {
if (!isPerformingRefresh) {
// If it was intentionally scheduled, don't attempt to restore.
// This includes intentionally scheduled unmounts.
failedRoots.delete(root);
if (rootElements !== null) {
rootElements.set(root, children);
}
}
return oldOnScheduleFiberRoot.apply(this, arguments);
};
hook.onCommitFiberRoot = function (id, root, maybePriorityLevel, didError) {
var helpers = helpersByRendererID.get(id);
if (helpers !== undefined) {
helpersByRoot.set(root, helpers);
var current = root.current;
var alternate = current.alternate; // We need to determine whether this root has just (un)mounted.
// This logic is copy-pasted from similar logic in the DevTools backend.
// If this breaks with some refactoring, you'll want to update DevTools too.
if (alternate !== null) {
var wasMounted = alternate.memoizedState != null && alternate.memoizedState.element != null && mountedRoots.has(root);
var isMounted = current.memoizedState != null && current.memoizedState.element != null;
if (!wasMounted && isMounted) {
// Mount a new root.
mountedRoots.add(root);
failedRoots.delete(root);
} else if (wasMounted && isMounted) ; else if (wasMounted && !isMounted) {
// Unmount an existing root.
mountedRoots.delete(root);
if (didError) {
// We'll remount it on future edits.
failedRoots.add(root);
} else {
helpersByRoot.delete(root);
function setSignature(type, key) {
var forceReset =
2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : !1,
getCustomHooks = 3 < arguments.length ? arguments[3] : void 0;
allSignaturesByType.has(type) ||
allSignaturesByType.set(type, {
forceReset: forceReset,
ownKey: key,
fullKey: null,
getCustomHooks:
getCustomHooks ||
function () {
return [];
}
} else if (!wasMounted && !isMounted) {
if (didError) {
// We'll remount it on future edits.
failedRoots.add(root);
}
}
} else {
// Mount a new root.
mountedRoots.add(root);
});
if ("object" === typeof type && null !== type)
switch (getProperty(type, "$$typeof")) {
case REACT_FORWARD_REF_TYPE:
setSignature(type.render, key, forceReset, getCustomHooks);
break;
case REACT_MEMO_TYPE:
setSignature(type.type, key, forceReset, getCustomHooks);
}
} // Always call the decorated DevTools hook.
return oldOnCommitFiberRoot.apply(this, arguments);
}
function collectCustomHooksForSignature(type) {
type = allSignaturesByType.get(type);
void 0 !== type && computeFullKey(type);
}
var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
REACT_MEMO_TYPE = Symbol.for("react.memo"),
PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map,
allFamiliesByID = new Map(),
allFamiliesByType = new PossiblyWeakMap(),
allSignaturesByType = new PossiblyWeakMap(),
updatedFamiliesByType = new PossiblyWeakMap(),
pendingUpdates = [],
helpersByRendererID = new Map(),
helpersByRoot = new Map(),
mountedRoots = new Set(),
failedRoots = new Set(),
rootElements = "function" === typeof WeakMap ? new WeakMap() : null,
isPerformingRefresh = !1;
exports._getMountedRootCount = function () {
return mountedRoots.size;
};
}
}
function hasUnrecoverableErrors() {
// TODO: delete this after removing dependency in RN.
return false;
} // Exposed for testing.
function _getMountedRootCount() {
{
return mountedRoots.size;
}
} // This is a wrapper over more primitive functions for setting signature.
// Signatures let us decide whether the Hook order has changed on refresh.
//
// This function is intended to be used as a transform target, e.g.:
// var _s = createSignatureFunctionForTransform()
//
// function Hello() {
// const [foo, setFoo] = useState(0);
// const value = useCustomHook();
// _s(); /* Call without arguments triggers collecting the custom Hook list.
// * This doesn't happen during the module evaluation because we
// * don't want to change the module order with inline requires.
// * Next calls are noops. */
// return <h1>Hi</h1>;
// }
//
// /* Call with arguments attaches the signature to the type: */
// _s(
// Hello,
// 'useState{[foo, setFoo]}(0)',
// () => [useCustomHook], /* Lazy to avoid triggering inline requires */
// );
function createSignatureFunctionForTransform() {
{
var savedType;
var hasCustomHooks;
var didCollectHooks = false;
return function (type, key, forceReset, getCustomHooks) {
if (typeof key === 'string') {
// We're in the initial phase that associates signatures
// with the functions. Note this may be called multiple times
// in HOC chains like _s(hoc1(_s(hoc2(_s(actualFunction))))).
if (!savedType) {
// We're in the innermost call, so this is the actual type.
savedType = type;
hasCustomHooks = typeof getCustomHooks === 'function';
} // Set the signature for all types (even wrappers!) in case
// they have no signatures of their own. This is to prevent
// problems like https://github.com/facebook/react/issues/20417.
if (type != null && (typeof type === 'function' || typeof type === 'object')) {
setSignature(type, key, forceReset, getCustomHooks);
}
return type;
} else {
// We're in the _s() call without arguments, which means
// this is the time to collect custom Hook signatures.
// Only do this once. This path is hot and runs *inside* every render!
if (!didCollectHooks && hasCustomHooks) {
didCollectHooks = true;
collectCustomHooksForSignature(savedType);
}
exports.collectCustomHooksForSignature = collectCustomHooksForSignature;
exports.createSignatureFunctionForTransform = function () {
var savedType,
hasCustomHooks,
didCollectHooks = !1;
return function (type, key, forceReset, getCustomHooks) {
if ("string" === typeof key)
return (
savedType ||
((savedType = type),
(hasCustomHooks = "function" === typeof getCustomHooks)),
null == type ||
("function" !== typeof type && "object" !== typeof type) ||
setSignature(type, key, forceReset, getCustomHooks),
type
);
!didCollectHooks &&
hasCustomHooks &&
((didCollectHooks = !0), collectCustomHooksForSignature(savedType));
};
};
exports.findAffectedHostInstances = function (families) {
var affectedInstances = new Set();
mountedRoots.forEach(function (root) {
var helpers = helpersByRoot.get(root);
if (void 0 === helpers)
throw Error(
"Could not find helpers for a root. This is a bug in React Refresh."
);
helpers
.findHostInstancesForRefresh(root, families)
.forEach(function (inst) {
affectedInstances.add(inst);
});
});
return affectedInstances;
};
exports.getFamilyByID = function (id) {
return allFamiliesByID.get(id);
};
exports.getFamilyByType = function (type) {
return allFamiliesByType.get(type);
};
exports.hasUnrecoverableErrors = function () {
return !1;
};
exports.injectIntoGlobalHook = function (globalObject) {
var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;
if (void 0 === hook) {
var nextID = 0;
globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
renderers: new Map(),
supportsFiber: !0,
inject: function () {
return nextID++;
},
onScheduleFiberRoot: function () {},
onCommitFiberRoot: function () {},
onCommitFiberUnmount: function () {}
};
}
if (hook.isDisabled)
console.warn(
"Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). Fast Refresh is not compatible with this shim and will be disabled."
);
else {
var oldInject = hook.inject;
hook.inject = function (injected) {
var id = oldInject.apply(this, arguments);
"function" === typeof injected.scheduleRefresh &&
"function" === typeof injected.setRefreshHandler &&
helpersByRendererID.set(id, injected);
return id;
};
hook.renderers.forEach(function (injected, id) {
"function" === typeof injected.scheduleRefresh &&
"function" === typeof injected.setRefreshHandler &&
helpersByRendererID.set(id, injected);
});
var oldOnCommitFiberRoot = hook.onCommitFiberRoot,
oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function () {};
hook.onScheduleFiberRoot = function (id, root, children) {
isPerformingRefresh ||
(failedRoots.delete(root),
null !== rootElements && rootElements.set(root, children));
return oldOnScheduleFiberRoot.apply(this, arguments);
};
hook.onCommitFiberRoot = function (
id,
root,
maybePriorityLevel,
didError
) {
var helpers = helpersByRendererID.get(id);
if (void 0 !== helpers) {
helpersByRoot.set(root, helpers);
helpers = root.current;
var alternate = helpers.alternate;
null !== alternate
? ((alternate =
null != alternate.memoizedState &&
null != alternate.memoizedState.element &&
mountedRoots.has(root)),
(helpers =
null != helpers.memoizedState &&
null != helpers.memoizedState.element),
!alternate && helpers
? (mountedRoots.add(root), failedRoots.delete(root))
: (alternate && helpers) ||
(alternate && !helpers
? (mountedRoots.delete(root),
didError
? failedRoots.add(root)
: helpersByRoot.delete(root))
: alternate ||
helpers ||
(didError && failedRoots.add(root))))
: mountedRoots.add(root);
}
return oldOnCommitFiberRoot.apply(this, arguments);
};
}
};
}
}
function isLikelyComponentType(type) {
{
switch (typeof type) {
case 'function':
{
// First, deal with classes.
if (type.prototype != null) {
if (type.prototype.isReactComponent) {
// React class.
return true;
}
exports.isLikelyComponentType = function (type) {
switch (typeof type) {
case "function":
if (null != type.prototype) {
if (type.prototype.isReactComponent) return !0;
var ownNames = Object.getOwnPropertyNames(type.prototype);
if (ownNames.length > 1 || ownNames[0] !== 'constructor') {
// This looks like a class.
return false;
} // eslint-disable-next-line no-proto
if (type.prototype.__proto__ !== Object.prototype) {
// It has a superclass.
return false;
} // Pass through.
// This looks like a regular function with empty prototype.
} // For plain functions and arrows, use name as a heuristic.
var name = type.name || type.displayName;
return typeof name === 'string' && /^[A-Z]/.test(name);
}
case 'object':
{
if (type != null) {
switch (getProperty(type, '$$typeof')) {
if (
1 < ownNames.length ||
"constructor" !== ownNames[0] ||
type.prototype.__proto__ !== Object.prototype
)
return !1;
}
type = type.name || type.displayName;
return "string" === typeof type && /^[A-Z]/.test(type);
case "object":
if (null != type)
switch (getProperty(type, "$$typeof")) {
case REACT_FORWARD_REF_TYPE:
case REACT_MEMO_TYPE:
// Definitely React components.
return true;
default:
return false;
return !0;
}
return !1;
default:
return !1;
}
};
exports.performReactRefresh = function () {
if (0 === pendingUpdates.length || isPerformingRefresh) return null;
isPerformingRefresh = !0;
try {
var staleFamilies = new Set(),
updatedFamilies = new Set(),
updates = pendingUpdates;
pendingUpdates = [];
updates.forEach(function (_ref) {
var family = _ref[0];
_ref = _ref[1];
var prevType = family.current;
updatedFamiliesByType.set(prevType, family);
updatedFamiliesByType.set(_ref, family);
family.current = _ref;
(prevType.prototype && prevType.prototype.isReactComponent) ||
(_ref.prototype && _ref.prototype.isReactComponent)
? (_ref = !1)
: ((prevType = allSignaturesByType.get(prevType)),
(_ref = allSignaturesByType.get(_ref)),
(_ref =
(void 0 === prevType && void 0 === _ref) ||
(void 0 !== prevType &&
void 0 !== _ref &&
computeFullKey(prevType) === computeFullKey(_ref) &&
!_ref.forceReset)
? !0
: !1));
_ref ? updatedFamilies.add(family) : staleFamilies.add(family);
});
var update = {
updatedFamilies: updatedFamilies,
staleFamilies: staleFamilies
};
helpersByRendererID.forEach(function (helpers) {
helpers.setRefreshHandler(resolveFamily);
});
var didError = !1,
firstError = null,
failedRootsSnapshot = cloneSet(failedRoots),
mountedRootsSnapshot = cloneSet(mountedRoots),
helpersByRootSnapshot = cloneMap(helpersByRoot);
failedRootsSnapshot.forEach(function (root) {
var helpers = helpersByRootSnapshot.get(root);
if (void 0 === helpers)
throw Error(
"Could not find helpers for a root. This is a bug in React Refresh."
);
failedRoots.has(root);
if (null !== rootElements && rootElements.has(root)) {
var element = rootElements.get(root);
try {
helpers.scheduleRoot(root, element);
} catch (err) {
didError || ((didError = !0), (firstError = err));
}
}
return false;
}
default:
{
return false;
}
}
}
}
exports._getMountedRootCount = _getMountedRootCount;
exports.collectCustomHooksForSignature = collectCustomHooksForSignature;
exports.createSignatureFunctionForTransform = createSignatureFunctionForTransform;
exports.findAffectedHostInstances = findAffectedHostInstances;
exports.getFamilyByID = getFamilyByID;
exports.getFamilyByType = getFamilyByType;
exports.hasUnrecoverableErrors = hasUnrecoverableErrors;
exports.injectIntoGlobalHook = injectIntoGlobalHook;
exports.isLikelyComponentType = isLikelyComponentType;
exports.performReactRefresh = performReactRefresh;
exports.register = register;
exports.setSignature = setSignature;
});
mountedRootsSnapshot.forEach(function (root) {
var helpers = helpersByRootSnapshot.get(root);
if (void 0 === helpers)
throw Error(
"Could not find helpers for a root. This is a bug in React Refresh."
);
mountedRoots.has(root);
try {
helpers.scheduleRefresh(root, update);
} catch (err) {
didError || ((didError = !0), (firstError = err));
}
});
if (didError) throw firstError;
return update;
} finally {
isPerformingRefresh = !1;
}
};
exports.register = register;
exports.setSignature = setSignature;
})();
}

110

cjs/react-refresh-runtime.production.js
/**
* @license React
* react-refresh-runtime.production.min.js
* react-refresh-runtime.production.js
*

@@ -11,105 +11,5 @@ * Copyright (c) Meta Platforms, Inc. and affiliates.

'use strict';
{
throw new Error('React Refresh runtime should not be included in the production bundle.');
} // In old environments, we'll leak previous types after every edit.
function performReactRefresh() {
{
throw new Error('Unexpected call to React Refresh in a production environment.');
}
}
function register(type, id) {
{
throw new Error('Unexpected call to React Refresh in a production environment.');
}
}
function setSignature(type, key) {
{
throw new Error('Unexpected call to React Refresh in a production environment.');
}
} // This is lazily called during first render for a type.
// It captures Hook list at that time so inline requires don't break comparisons.
function collectCustomHooksForSignature(type) {
{
throw new Error('Unexpected call to React Refresh in a production environment.');
}
}
function getFamilyByID(id) {
{
throw new Error('Unexpected call to React Refresh in a production environment.');
}
}
function getFamilyByType(type) {
{
throw new Error('Unexpected call to React Refresh in a production environment.');
}
}
function findAffectedHostInstances(families) {
{
throw new Error('Unexpected call to React Refresh in a production environment.');
}
}
function injectIntoGlobalHook(globalObject) {
{
throw new Error('Unexpected call to React Refresh in a production environment.');
}
}
function hasUnrecoverableErrors() {
// TODO: delete this after removing dependency in RN.
return false;
} // Exposed for testing.
function _getMountedRootCount() {
{
throw new Error('Unexpected call to React Refresh in a production environment.');
}
} // This is a wrapper over more primitive functions for setting signature.
// Signatures let us decide whether the Hook order has changed on refresh.
//
// This function is intended to be used as a transform target, e.g.:
// var _s = createSignatureFunctionForTransform()
//
// function Hello() {
// const [foo, setFoo] = useState(0);
// const value = useCustomHook();
// _s(); /* Call without arguments triggers collecting the custom Hook list.
// * This doesn't happen during the module evaluation because we
// * don't want to change the module order with inline requires.
// * Next calls are noops. */
// return <h1>Hi</h1>;
// }
//
// /* Call with arguments attaches the signature to the type: */
// _s(
// Hello,
// 'useState{[foo, setFoo]}(0)',
// () => [useCustomHook], /* Lazy to avoid triggering inline requires */
// );
function createSignatureFunctionForTransform() {
{
throw new Error('Unexpected call to React Refresh in a production environment.');
}
}
function isLikelyComponentType(type) {
{
throw new Error('Unexpected call to React Refresh in a production environment.');
}
}
exports._getMountedRootCount = _getMountedRootCount;
exports.collectCustomHooksForSignature = collectCustomHooksForSignature;
exports.createSignatureFunctionForTransform = createSignatureFunctionForTransform;
exports.findAffectedHostInstances = findAffectedHostInstances;
exports.getFamilyByID = getFamilyByID;
exports.getFamilyByType = getFamilyByType;
exports.hasUnrecoverableErrors = hasUnrecoverableErrors;
exports.injectIntoGlobalHook = injectIntoGlobalHook;
exports.isLikelyComponentType = isLikelyComponentType;
exports.performReactRefresh = performReactRefresh;
exports.register = register;
exports.setSignature = setSignature;
"use strict";
throw Error(
"React Refresh runtime should not be included in the production bundle."
);

7

package.json

@@ -7,4 +7,4 @@ {

],
"version": "0.0.0-experimental-a515d753b-20240220",
"homepage": "https://reactjs.org/",
"version": "0.0.0-experimental-a532d91d01-20240610",
"homepage": "https://react.dev/",
"bugs": "https://github.com/facebook/react/issues",

@@ -17,4 +17,3 @@ "license": "MIT",

"runtime.js",
"cjs/",
"umd/"
"cjs/"
],

@@ -21,0 +20,0 @@ "main": "runtime.js",

2

runtime.js
'use strict';
if (process.env.NODE_ENV === 'production') {
module.exports = require('./cjs/react-refresh-runtime.production.min.js');
module.exports = require('./cjs/react-refresh-runtime.production.js');
} else {
module.exports = require('./cjs/react-refresh-runtime.development.js');
}
cjs/react-refresh-babel.production.min.js
cjs/react-refresh-babel.production.min.js.map
cjs/react-refresh-runtime.production.min.js
cjs/react-refresh-runtime.production.min.js.map
SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

About

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc