{"version":3,"sources":["jsdelivr-header.js","/npm/babel-plugin-lazy-action-creator@1.0.3/index.js"],"names":[],"mappings":"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","file":"/npm/babel-plugin-lazy-action-creator@1.0.3/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/babel-plugin-lazy-action-creator@1.0.3/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","\"use strict\";\n\nexports.__esModule = true;\n\nexports.default = function ({ types: t }) {\n  return {\n    name: \"babel-plugin-lazy-action-creator\",\n    visitor: {\n      CallExpression(path) {\n\n        if (path.node.callee.name !== \"connect\") {\n          return;\n        }\n        if (isDisableFile(path.findParent(p=>p.isProgram()))) {\n          return;\n        }\n        if(path.hub.file.opts.filename.includes(\"node_module\")){\n          return;\n        }\n        const mapDispatchToPropsNode = getMapDispatchToPropsNode(path);\n        if(!mapDispatchToPropsNode){\n          return;\n        }\n\n        let isMapDispatchToPropsObject = false;\n        let {\n          returnStatement,\n          aMDTPDecl,\n          isConnectItselfContainingDeclaration\n        } = getReturnStatement(path, mapDispatchToPropsNode)||{};  //ObjectExpression|ArrowFunctionExpression|FunctionExpression\n        if(!returnStatement){\n          return;\n        }\n        if (returnStatement.node.type === \"ObjectExpression\") {\n          isMapDispatchToPropsObject = true;\n        }\n        if (!isMapDispatchToPropsObject && returnStatement.node.argument.type !== \"ObjectExpression\") {\n          return;\n        }\n        modifyReturnStatetmentWithDynamicImport(returnStatement, t, isMapDispatchToPropsObject, path);\n        updateNodePath(isMapDispatchToPropsObject, isConnectItselfContainingDeclaration, t, aMDTPDecl, path);\n      }\n    }\n  };\n};\n\n\nconst SPECIFIER_TYPES = {\n  ImportDefaultSpecifier: \"ImportDefaultSpecifier\",\n  ImportNamespaceSpecifier: \"ImportNamespaceSpecifier\",\n  ImportSpecifier: \"ImportSpecifier\"\n};\nconst COMMENT_TYPE_REGEX = /\\s*babel\\s+lazy\\-action\\-creator\\:\\s+\\\"disable\\\"\\s*/;\n\nfunction updateNodePath(isMapDispatchToPropsObject, isConnectItselfContainingDeclaration, t, aMDTPDecl, path) {\n  if (isMapDispatchToPropsObject && !isConnectItselfContainingDeclaration) {\n    const returnStatement = t.returnStatement(aMDTPDecl.node.init);\n    const BlockStatement = t.blockStatement([returnStatement]);\n    const arrowFunction = t.arrowFunctionExpression(\n      [t.identifier(\"dispatch\")],\n      BlockStatement);\n    const mdp = t.variableDeclarator(aMDTPDecl.node.id, arrowFunction);\n    aMDTPDecl.replaceWith(mdp);\n  }\n  else if (isMapDispatchToPropsObject && isConnectItselfContainingDeclaration) {\n    const arrowFuncBody = t.arrowFunctionExpression([t.identifier(\"dispatch\")], path.node.arguments[1]);\n    const duplicateConnect = t.callExpression(t.identifier(\"connect\"), [path.node.arguments[0], arrowFuncBody]);\n    path.parentPath.node[path.key] = duplicateConnect;\n  }\n}\n\nfunction isDisableFile(program) {\n  for (let i = 0; program.node.body && i < program.node.body.length; i++) {\n    const bodyElement = program.node.body[i];\n    for (let j = 0; bodyElement.leadingComments && j < bodyElement.leadingComments.length; j++) {\n      let comment = bodyElement.leadingComments[j];\n      const { type, value } = comment;\n      if (type === \"CommentBlock\" && COMMENT_TYPE_REGEX.test(value.trim())) {\n        return true;\n      }\n    }\n  };\n}\n\nfunction getReturnStatementProperties(returnStatement, isMapDispatchToPropsObject) {\n  if (!isMapDispatchToPropsObject) {\n    return returnStatement.get(\"argument\").get(\"properties\");\n  }\n  return returnStatement.get(\"properties\");\n}\nfunction calculateOriginalActionNameAndSpecifier(returnArgument) { // ArrowFunctionExpression|FunctionExpression|Identifier|MemberExpression\n  let originalActionName, originalActionSpecifier;\n  switch (returnArgument.node.type) {\n    case \"Identifier\": {\n      originalActionName = returnArgument.node.name;\n      originalActionSpecifier = returnArgument.node.name;\n      break;\n    }\n    case \"MemberExpression\": {\n      originalActionName = returnArgument.node.object.name;\n      originalActionSpecifier = returnArgument.node.property.name;\n      break;\n    }\n    case \"FunctionExpression\":\n    case \"ArrowFunctionExpression\": {\n      returnArgument.traverse({\n        CallExpression(dispatchNode) {\n          //considering only one dispatch method will be in the callback\n          if (dispatchNode.node.callee.name !== \"dispatch\") {\n            return;\n          }\n          const actionCallNode = dispatchNode.get(\"arguments\")[0];\n          const { callee } = actionCallNode.node;\n          if (callee.type === \"Identifier\") {\n            originalActionName = callee.name;\n          } else if (callee.type === \"MemberExpression\") {\n            originalActionName = callee.object.name;\n            originalActionSpecifier = callee.property.name;\n          }\n        }\n      });\n      break;\n    }\n    default:\n  }\n  return {\n    originalActionName,\n    originalActionSpecifier\n  }\n}\nfunction getOriginalParams(t, prop, isMapDispatchToPropsObject) {\n  if (isMapDispatchToPropsObject) {\n    return t.restElement(t.identifier(\"rest\")); //passing reset operator for object type\n  }\n  //console.log(\"prop\", prop);\n  return prop.node.value.params;\n\n}\n\n\nfunction modifyReturnStatetmentWithDynamicImport(returnStatement, t, isMapDispatchToPropsObject, path) {\n  const properties = getReturnStatementProperties(returnStatement, isMapDispatchToPropsObject); // [ObjectProperty(key, value)]\n  for (let i = 0; i < properties.length; i++) {\n    let prop = properties[i]; //ObjectProperty(key, value)\n    if (isPluginDisableForProperty(prop)) {\n      continue;\n    }\n    const returnArgument = prop.get(\"value\"); //ArrowFunctionExpression|FunctionExpression|Identifier|MemberExpression\n    let {\n      originalActionName,\n      originalActionSpecifier\n    } = calculateOriginalActionNameAndSpecifier(returnArgument);\n\n    const actionNameAsProp = prop.node.key.name;\n    const {\n      importStatement,\n      specifierType,\n      specifier,\n      namedImport\n    } = getImportStatement(returnStatement, originalActionName);\n\n    const originalParams = getOriginalParams(t, prop, isMapDispatchToPropsObject);\n\n    const modifiedFunction = constructLazyActionCreator(\n      t,\n      returnStatement,\n      originalParams,\n      prop,\n      originalActionName,\n      importStatement,\n      specifierType,\n      specifier,\n      originalActionSpecifier,\n      namedImport,\n      isMapDispatchToPropsObject,\n    );\n\n    //console.log(\"modifiedFunction===\", modifiedFunction, actionNameAsProp)\n    cleanUpImportStatement(importStatement, originalActionName);\n    //let prog = path.findParent((p) => p.isProgram());\n    //console.log(\"program===\", prog);\n    //prog.node.body.push(modifiedFunction);\n    if (isMapDispatchToPropsObject) {\n      prop.node.value = modifiedFunction\n\n    } else {\n      returnStatement.traverse({\n        ObjectExpression(innerPath) {\n          const objectProperty = t.objectProperty(t.identifier(actionNameAsProp), modifiedFunction);\n          innerPath.node.properties[i] = objectProperty;\n        }\n      });\n    }\n\n  }\n}\n\nfunction isPluginDisableForProperty(path) {\n  return (path.node.leadingComments || []).filter(({ type, value }) =>\n    type === \"CommentBlock\" && COMMENT_TYPE_REGEX.test(value)).length;\n}\n\nfunction constructLazyActionCreator(\n  t,\n  path,\n  originalParams,\n  prop,\n  originalActionName,\n  importStatement,\n  specifierType,\n  specifier,\n  originalActionSpecifier,\n  namedImport,\n  isMapDispatchToPropsObject\n) {\n\n  const filename = importStatement.node.source.value;\n  const importState = t.memberExpression(t.callExpression(t.import(), [t.stringLiteral(filename)]), t.identifier(\"then\"));\n  // let prog = path.findParent((p) => p.isProgram());\n  // prog.node.body.push(importState);\n  let objectState;\n  let keyname = originalActionName;\n  if (specifierType === \"ImportSpecifier\") {\n    keyname = namedImport;\n  } else if (specifierType === \"ImportDefaultSpecifier\") {\n    keyname = \"default\";\n  }\n  if (specifierType === \"ImportNamespaceSpecifier\") {\n    objectState = t.identifier(originalActionName);\n  } else {\n    objectState = t.objectPattern([t.objectProperty(t.identifier(keyname), t.identifier(originalActionName))]);\n  }\n\n  const arrowFuncBody = getActionDispatcherBody(\n    t,\n    prop,\n    isMapDispatchToPropsObject,\n    originalParams,\n    originalActionName,\n    originalActionSpecifier,\n    specifierType\n  );\n\n  const args = t.arrowFunctionExpression([objectState], arrowFuncBody);\n  const returnStatement = t.callExpression(importState, [args]);\n  const params = isMapDispatchToPropsObject ? [originalParams] : originalParams;\n  const outerFunction = t.arrowFunctionExpression(params, returnStatement);\n  // let prog = path.findParent((p) => p.isProgram());\n  //prog.node.body.push(outerFunction);\n  return outerFunction;\n}\n\nfunction getActionDispatcherBody(\n  t,\n  prop,\n  isMapDispatchToPropsObject,\n  originalParams,\n  originalActionName,\n  originalActionSpecifier,\n  specifierType\n) {\n  if (!isMapDispatchToPropsObject) {\n    return prop.node.value.body;\n  }\n  let functionName = t.identifier(originalActionName);\n  if (specifierType === \"ImportNamespaceSpecifier\") {\n    functionName = t.memberExpression(functionName, t.identifier(originalActionSpecifier))\n  }\n  //generating---> dispatch(addition(...rest))\n  const customDispatchMethod = t.callExpression(\n    t.identifier(\"dispatch\"),\n    [\n      t.callExpression(functionName,\n        [t.spreadElement(t.identifier(originalParams.argument.name))])\n    ]\n  );\n  return customDispatchMethod;\n}\n\n\nfunction cleanUpImportStatement(importStatement, actionName) {\n  //stop traversal as soon as action name is matched\n  importStatement.traverse({\n    ImportDefaultSpecifier(specifierPath) {\n      removeSpecifierHandler(importStatement, specifierPath, actionName);\n    },\n    ImportSpecifier(specifierPath) {\n      removeSpecifierHandler(importStatement, specifierPath, actionName);\n    },\n    ImportNamespaceSpecifier(specifierPath) {\n      removeSpecifierHandler(importStatement, specifierPath, actionName);\n    }\n  });\n}\n\nfunction removeSpecifierHandler(importStatement, specifierPath, actionName) {\n  if (specifierPath.node.local.name === actionName) {\n    if (importStatement.node.specifiers && importStatement.node.specifiers.length === 1) {\n      importStatement.remove();\n    } else {\n      specifierPath.remove();\n    }\n  }\n}\nfunction getImportStatement(path, requiredSpecifierName) {\n  const program = path.findParent((p) => p.isProgram());\n  const programBody = program.get(\"body\");\n\n  const importDeclarations = programBody.filter((path) => path.node.type === \"ImportDeclaration\");\n\n  let importStatement, specifierType, matchedSpecifier, namedImport;\n\n  for (let i = 0; i < importDeclarations.length; i++) {\n    const importDeclaration = importDeclarations[i];\n    const specifiersNode = importDeclaration.node.specifiers;\n\n    if (specifiersNode && specifiersNode.length) {\n      for (let i = 0; i < specifiersNode.length; i++) {\n        const specifier = specifiersNode[i];\n        const { specifierType: specType, status, namedImport: originalNamedImport } = isSpecifierContainRequiredSpecifier(specifier, requiredSpecifierName);\n        if (status) {\n          importStatement = importDeclaration;\n          specifierType = specType;\n          matchedSpecifier = specifier;\n          namedImport = originalNamedImport;\n          break;\n        }\n      }\n    }\n  }\n  return {\n    importStatement,\n    specifierType,\n    specifier: matchedSpecifier,\n    namedImport: namedImport\n  };\n}\n\nfunction isSpecifierContainRequiredSpecifier(specifier, requiredSpecifierName) {\n  const { local, imported } = specifier;\n  let status = false;\n  switch (specifier.type) {\n    case SPECIFIER_TYPES.ImportDefaultSpecifier:\n    case SPECIFIER_TYPES.ImportNamespaceSpecifier:\n    case SPECIFIER_TYPES.ImportSpecifier: {\n      status = local.name === requiredSpecifierName;\n      break;\n    }\n    default: {\n      status = false;\n    }\n  }\n  return {\n    status,\n    specifierType: specifier.type,\n    namedImport: imported ? imported.name : null\n  };\n}\n//refactor this code using switch\nfunction getReturnStatement(path, mapDispatchToPropsNode) {\n  if(mapDispatchToPropsNode.node.type === \"ObjectExpression\"){\n    return {\n      returnStatement: mapDispatchToPropsNode,\n      isConnectItselfContainingDeclaration: true,\n      aMDTPDecl: undefined\n    };\n  }else if(mapDispatchToPropsNode.node.type === \"Identifier\"){\n    const mapDispatchToPropsName = mapDispatchToPropsNode.node.name;\n    const program = getParentProgram(path);\n    let aMDTPDecl = getACtualMapDispToPropsDeclaration({ program, mapDispatchToPropsName });\n\n\n    let returnStatement;\n    let declarator = aMDTPDecl.get(\"init\").node? aMDTPDecl.get(\"init\"): aMDTPDecl.get(\"body\");\n    if (declarator.node.type === \"ObjectExpression\") {\n      return {\n        returnStatement: declarator,\n        isConnectItselfContainingDeclaration: false,\n        aMDTPDecl: aMDTPDecl\n      };\n    }else { //add conditions\n      let outerReturn = false;\n      declarator.traverse({\n        ReturnStatement(path) {\n          if (outerReturn) {\n            return;\n          }\n          returnStatement = path;\n          outerReturn = true;\n        }\n      });\n      outerReturn = false;\n      return {\n        returnStatement: returnStatement,\n        isConnectItselfContainingDeclaration: false,\n        aMDTPDecl: aMDTPDecl\n      };\n    }\n  }\n}\n\n\n\nfunction getACtualMapDispToPropsDeclaration({ program, mapDispatchToPropsName }) {\n  let actualMapDispToPropsDeclaration;\n  const body = program.node.body;\n  const rootLevelVariableDeclaration = program.get(\"body\").filter((child) => {\n    if (child.node.type === \"VariableDeclaration\" || child.node.type === \"FunctionDeclaration\") {\n      return true;\n    }\n  });\n  for (let i = 0; i < rootLevelVariableDeclaration.length; i++) {\n    const variableDeclaration = rootLevelVariableDeclaration[i];\n\n    if (variableDeclaration.node.type === \"VariableDeclaration\") {\n      const declarations = variableDeclaration.get(\"declarations\");\n      for (let j = 0; j < declarations.length; j++) {\n        const declaration = declarations[j];\n        if (declaration.node.id.name === mapDispatchToPropsName) {\n          //add regex\n          //actualMapDispToPropsDeclaration = declaration;\n          return declaration;\n          break;\n        }\n      }\n    } else if (variableDeclaration.node.type === \"FunctionDeclaration\") {\n      if(variableDeclaration.node.id.name===mapDispatchToPropsName){\n        return variableDeclaration;\n      }\n    }\n  }\n  // return actualMapDispToPropsDeclaration;\n}\n\n\nfunction getParentProgram(path) {\n  return path.findParent(p => p.isProgram());\n}\n\n\n//path=> connect statement\n//return=>return second params name in connect statement as node\nfunction getMapDispatchToPropsNode(path) {\n  const args = path.get(\"arguments\");\n  if (args.length > 1) {\n    return args[1];\n  }\n  return undefined;\n}\n\n\n"]}