{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-tabs/src/client/reactive/babel-plugin-ILA/index.js"],"names":["getSourceLocation","babel","types","t","template","transformFromAst","traverse","buildAEGenerator","parentStatement","path","isStatement","node","parentPath","createILA","callExpression","AEGeneratorStatement","arrowFunction","expression","condition","body","arguments","originalCondition","loc","start","end","AEIdentifier","callee","push","replaceWith","buildFunctionDebugInfo","addRefineInfo","state","debugInfos","objectExpressionPath","get","isObjectExpression","lively","warn","refinedFunctions","refinedFunctionPath","location","objectProperty","key","FNNAME","LOCATION","CODE","stringLiteral","getSource","pushContainer","objectExpression","name","visitor","Program","enter","ppath","CallExpression","isMemberExpression","isIdentifier","property","length"],"mappings":"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","file":"index.js","sourcesContent":["import { getSourceLocation } from 'src/client/reactive/babel-plugin-active-expression-rewriting/index.js'\n\nexport default function (babel) {\n  const { types: t, template, transformFromAst, traverse } = babel;\n\n  \n  const buildAEGenerator = template(`(cond, layer) => aexpr(cond, {isILA: true, ila: layer})`);\n  \n  function parentStatement(path) {\n    while(!t.isStatement(path.node)) {\n      return parentStatement(path.parentPath);\n    }\n    return path;\n  }\n  \n  function createILA(callExpression, path) {    \n    const AEGeneratorStatement = buildAEGenerator();\n    \n    const arrowFunction = AEGeneratorStatement.expression;     \n    const condition = arrowFunction.body.arguments[0];\n    const originalCondition = callExpression.arguments[0];\n    condition.loc = originalCondition.loc;\n    condition.start = originalCondition.start;\n    condition.end = originalCondition.end;\n    \n    const AEIdentifier = arrowFunction.body.callee;\n    AEIdentifier.loc = callExpression.loc;\n    \n    callExpression.arguments.push(arrowFunction);\n    path.replaceWith(callExpression)\n  }\n  \n  const buildFunctionDebugInfo = template(`({ location: LOCATION, code: CODE })`)\n  \n  function addRefineInfo(callExpression, path, state) {  \n    const debugInfos = [];\n    const objectExpressionPath = path.get(\"arguments\")[1];\n    if(!t.isObjectExpression(objectExpressionPath.node)) {\n      \n      lively.warn(\"Second object refinement argument of layer is not an objectExpression. We do currently not support searching for the root. No debug info is provided.\");\n      return;\n    }\n    const refinedFunctions = objectExpressionPath.get(\"properties\"); //Array of ObjectMethods\n    for(const refinedFunctionPath of refinedFunctions) {\n      const node = refinedFunctionPath.node;\n      const location = getSourceLocation(node, state, template, t);\n      debugInfos.push(t.objectProperty(node.key, buildFunctionDebugInfo({FNNAME: node.key, LOCATION: location, CODE: t.stringLiteral(refinedFunctionPath.getSource())}).expression));\n    }\n    path.pushContainer('arguments', t.objectExpression(debugInfos));\n  }\n  \n  \n  return {\n    name: \"data-binding\",\n    visitor: {\n      Program: {\n        enter(ppath, state) {\n          ppath.traverse({\n            CallExpression(path) {\n              const node = path.node;\n              if(!t.isMemberExpression(node.callee)) {\n                // Free function\n                return;\n              }              \n              if(t.isIdentifier(node.callee.property, { name: \"activeWhile\" })) {\n                if(node.arguments.length !== 1) {\n                  // Wrong amount of arguments;\n                  lively.warn(\"Did not rewrite possible ILA, due to wrong amount of parameters: \" + node.arguments.length + \" instead of 1!\");\n                  return;\n                }              \n                // We assume this call expression is for an ILA\n                createILA(node, path);\n              } else if (t.isIdentifier(node.callee.property, { name: \"refineObject\" })) {\n                addRefineInfo(node, path, state);\n              } else {\n                // Wrong name or computed property access which is probably wrong\n                return;\n                \n              }\n            }\n          });\n        }\n      }\n    }\n  };\n}"]}