AutoAndroidController/node_modules/react-refresh/cjs/react-refresh-babel.production.js

/**
 * @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));
              });
            }
          }
        }
      }
    }
  };
};