diff options
Diffstat (limited to 'node_modules/react-refresh/cjs')
4 files changed, 1539 insertions, 0 deletions
diff --git a/node_modules/react-refresh/cjs/react-refresh-babel.development.js b/node_modules/react-refresh/cjs/react-refresh-babel.development.js new file mode 100644 index 0000000..360fa06 --- /dev/null +++ b/node_modules/react-refresh/cjs/react-refresh-babel.development.js @@ -0,0 +1,601 @@ +/** + * @license React + * react-refresh-babel.development.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"; +"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; + } + 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)); + }); + } + } + } + } + } + }; + }); 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)); + }); + } + } + } + } + } + }; +}; diff --git a/node_modules/react-refresh/cjs/react-refresh-runtime.development.js b/node_modules/react-refresh/cjs/react-refresh-runtime.development.js new file mode 100644 index 0000000..b0b84c1 --- /dev/null +++ b/node_modules/react-refresh/cjs/react-refresh-runtime.development.js @@ -0,0 +1,338 @@ +/** + * @license React + * react-refresh-runtime.development.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"; +"production" !== process.env.NODE_ENV && + (function () { + function computeFullKey(signature) { + if (null !== signature.fullKey) return signature.fullKey; + var fullKey = signature.ownKey; + try { + var hooks = signature.getCustomHooks(); + } catch (err) { + return (signature.forceReset = !0), (signature.fullKey = fullKey); + } + 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; + } + } + return (signature.fullKey = fullKey); + } + function resolveFamily(type) { + return updatedFamiliesByType.get(type); + } + 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; + } + function getProperty(object, property) { + try { + return object[property]; + } catch (err) {} + } + 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"); + } + } + } + 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 []; + } + }); + 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); + } + } + 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; + }; + 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.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); + }; + } + }; + 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 ( + 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: + 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)); + } + } + }); + 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; + })(); diff --git a/node_modules/react-refresh/cjs/react-refresh-runtime.production.js b/node_modules/react-refresh/cjs/react-refresh-runtime.production.js new file mode 100644 index 0000000..26e566f --- /dev/null +++ b/node_modules/react-refresh/cjs/react-refresh-runtime.production.js @@ -0,0 +1,14 @@ +/** + * @license React + * react-refresh-runtime.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"; +throw Error( + "React Refresh runtime should not be included in the production bundle." +); |