diff options
Diffstat (limited to 'node_modules/react-refresh/cjs/react-refresh-babel.production.js')
| -rw-r--r-- | node_modules/react-refresh/cjs/react-refresh-babel.production.js | 586 |
1 files changed, 586 insertions, 0 deletions
diff --git a/node_modules/react-refresh/cjs/react-refresh-babel.production.js b/node_modules/react-refresh/cjs/react-refresh-babel.production.js new file mode 100644 index 0000000..3a0dd6b --- /dev/null +++ b/node_modules/react-refresh/cjs/react-refresh-babel.production.js @@ -0,0 +1,586 @@ +/** + * @license React + * react-refresh-babel.production.js + * + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +"use strict"; +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; + } + function isComponentishName(name) { + return "string" === typeof name && "A" <= name[0] && "Z" >= name[0]; + } + function findInnerComponents(inferredName, path, callback) { + var node = path.node; + switch (node.type) { + 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 "VariableDeclarator": + if ( + ((argsPath = node.init), + null !== argsPath && + ((calleePath = node.id.name), isComponentishName(calleePath))) + ) { + switch (argsPath.type) { + case "ArrowFunctionExpression": + case "FunctionExpression": + break; + 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; + } + 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; + } + } + } + } + return !1; + } + 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 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; + } + 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; + } + 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; + } + } + 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 }); + } + } + }; + 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) + )); + } + ); + } + }, + 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": + 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; + } + 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) + )); + } + ); + } + }, + 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)); + }); + } + } + } + } + } + }; +}; |