owl/tests/compiler/__snapshots__/t_if.test.ts.snap

// Jest Snapshot v1, https://goo.gl/fbAQLP

exports[`t-if a t-if next to a div 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block2 = createBlock(\`<div>foo</div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3;
    b2 = block2();
    if (ctx['cond']) {
      b3 = text(\`1\`);
    }
    return multi([b2, b3]);
  }
}"
`;

exports[`t-if a t-if with two inner nodes 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block3 = createBlock(\`<span>yip</span>\`);
  let block4 = createBlock(\`<div>yip</div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2;
    if (ctx['condition']) {
      let b3 = block3();
      let b4 = block4();
      b2 = multi([b3, b4]);
    }
    return multi([b2]);
  }
}"
`;

exports[`t-if boolean value condition elif (no outside node) 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3,b4,b5;
    if (ctx['color']=='black') {
      b2 = text(\`black pearl\`);
    } else if (ctx['color']=='yellow') {
      b3 = text(\`yellow submarine\`);
    } else if (ctx['color']=='red') {
      b4 = text(\`red is dead\`);
    } else {
      b5 = text(\`beer\`);
    }
    return multi([b2, b3, b4, b5]);
  }
}"
`;

exports[`t-if boolean value condition elif 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/><block-child-1/><block-child-2/><block-child-3/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3,b4,b5;
    if (ctx['color']=='black') {
      b2 = text(\`black pearl\`);
    } else if (ctx['color']=='yellow') {
      b3 = text(\`yellow submarine\`);
    } else if (ctx['color']=='red') {
      b4 = text(\`red is dead\`);
    } else {
      b5 = text(\`beer\`);
    }
    return block1([], [b2, b3, b4, b5]);
  }
}"
`;

exports[`t-if boolean value condition else 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<div><span>begin</span><block-child-0/><block-child-1/><span>end</span></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3;
    if (ctx['condition']) {
      b2 = text(\`ok\`);
    } else {
      b3 = text(\`ok-else\`);
    }
    return block1([], [b2, b3]);
  }
}"
`;

exports[`t-if boolean value condition false else 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<div><span>begin</span><block-child-0/><block-child-1/><span>end</span></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3;
    if (ctx['condition']) {
      b2 = text(\`fail\`);
    } else {
      b3 = text(\`fail-else\`);
    }
    return block1([], [b2, b3]);
  }
}"
`;

exports[`t-if boolean value condition missing 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<span><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2;
    if (ctx['condition']) {
      b2 = text(\`fail\`);
    }
    return block1([], [b2]);
  }
}"
`;

exports[`t-if can use some boolean operators in expressions 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/><block-child-1/><block-child-2/><block-child-3/><block-child-4/><block-child-5/><block-child-6/><block-child-7/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3,b4,b5,b6,b7,b8,b9;
    if (ctx['cond1']&&ctx['cond2']) {
      b2 = text(\`and\`);
    }
    if (ctx['cond1']&&ctx['cond3']) {
      b3 = text(\`nope\`);
    }
    if (ctx['cond1']||ctx['cond3']) {
      b4 = text(\`or\`);
    }
    if (ctx['cond3']||ctx['cond4']) {
      b5 = text(\`nope\`);
    }
    if (ctx['m']>3) {
      b6 = text(\`mgt\`);
    }
    if (ctx['n']>3) {
      b7 = text(\`ngt\`);
    }
    if (ctx['m']<3) {
      b8 = text(\`mlt\`);
    }
    if (ctx['n']<3) {
      b9 = text(\`nlt\`);
    }
    return block1([], [b2, b3, b4, b5, b6, b7, b8, b9]);
  }
}"
`;

exports[`t-if div containing a t-if with two inner nodes 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  let block3 = createBlock(\`<span>yip</span>\`);
  let block4 = createBlock(\`<div>yip</div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2;
    if (ctx['condition']) {
      let b3 = block3();
      let b4 = block4();
      b2 = multi([b3, b4]);
    }
    return block1([], [b2]);
  }
}"
`;

exports[`t-if dynamic content after t-if with two children nodes 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/><block-text-0/></div>\`);
  let block3 = createBlock(\`<p>1</p>\`);
  let block4 = createBlock(\`<p>2</p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2;
    if (ctx['condition']) {
      let b3 = block3();
      let b4 = block4();
      b2 = multi([b3, b4]);
    }
    let d1 = ctx['text'];
    return block1([d1], [b2]);
  }
}"
`;

exports[`t-if just a t-if 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    let b2;
    if (ctx['condition']) {
      b2 = text(\`ok\`);
    }
    return multi([b2]);
  }
}"
`;

exports[`t-if simple t-if/t-else 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3;
    if (ctx['condition']) {
      b2 = text(\`1\`);
    } else {
      b3 = text(\`2\`);
    }
    return multi([b2, b3]);
  }
}"
`;

exports[`t-if simple t-if/t-else in a div 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3;
    if (ctx['condition']) {
      b2 = text(\`1\`);
    } else {
      b3 = text(\`2\`);
    }
    return block1([], [b2, b3]);
  }
}"
`;

exports[`t-if t-esc with t-elif 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3;
    if (false) {
      b2 = text(\`abc\`);
    } else {
      b3 = text('x');
    }
    return block1([], [b2, b3]);
  }
}"
`;

exports[`t-if t-esc with t-if 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2;
    if (true) {
      b2 = text('x');
    }
    return block1([], [b2]);
  }
}"
`;

exports[`t-if t-if and t-else with two nodes 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block4 = createBlock(\`<span>a</span>\`);
  let block5 = createBlock(\`<span>b</span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3;
    if (ctx['condition']) {
      b2 = text(\`1\`);
    } else {
      let b4 = block4();
      let b5 = block5();
      b3 = multi([b4, b5]);
    }
    return multi([b2, b3]);
  }
}"
`;

exports[`t-if t-if in a div 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2;
    if (ctx['condition']) {
      b2 = text(\`ok\`);
    }
    return block1([], [b2]);
  }
}"
`;

exports[`t-if t-if in a t-if 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  let block2 = createBlock(\`<span>1<block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2;
    if (ctx['cond1']) {
      let b3;
      if (ctx['cond2']) {
        b3 = text(\`2\`);
      }
      b2 = block2([], [b3]);
    }
    return block1([], [b2]);
  }
}"
`;

exports[`t-if t-if/t-else with more content 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3;
    if (ctx['condition']) {
      if (ctx['condition']) {
        b2 = text(\`asf\`);
      }
    } else {
      b3 = text(\`coucou\`);
    }
    return multi([b2, b3]);
  }
}"
`;

exports[`t-if t-set, then t-if 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1
    let b2;
    setContextValue(ctx, \\"title\\", 'test');
    if (ctx['title']) {
      b2 = text(ctx['title']);
    }
    return block1([], [b2]);
  }
}"
`;

exports[`t-if t-set, then t-if, part 2 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  let block2 = createBlock(\`<span>COUCOU</span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1
    let b2;
    setContextValue(ctx, \\"y\\", true);
    setContextValue(ctx, \\"x\\", ctx['y']);
    if (ctx['x']) {
      b2 = block2();
    }
    return block1([], [b2]);
  }
}"
`;

exports[`t-if t-set, then t-if, part 3 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
  let block2 = createBlock(\`<span>AAA</span>\`);
  let block3 = createBlock(\`<span>BBB</span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1
    let b2,b3;
    setContextValue(ctx, \\"y\\", false);
    setContextValue(ctx, \\"x\\", ctx['y']);
    if (ctx['x']) {
      b2 = block2();
    } else if (!ctx['x']) {
      b3 = block3();
    }
    return block1([], [b2, b3]);
  }
}"
`;

exports[`t-if two consecutive t-if 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3;
    if (ctx['cond1']) {
      b2 = text(\`1\`);
    }
    if (ctx['cond2']) {
      b3 = text(\`2\`);
    }
    return multi([b2, b3]);
  }
}"
`;

exports[`t-if two consecutive t-if in a div 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3;
    if (ctx['cond1']) {
      b2 = text(\`1\`);
    }
    if (ctx['cond2']) {
      b3 = text(\`2\`);
    }
    return block1([], [b2, b3]);
  }
}"
`;

exports[`t-if two t-ifs next to each other 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
  let block2 = createBlock(\`<span><block-text-0/></span>\`);
  let block4 = createBlock(\`<p>1</p>\`);
  let block5 = createBlock(\`<p>2</p>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2,b3;
    if (ctx['condition']) {
      let d1 = ctx['text'];
      b2 = block2([d1]);
    }
    if (ctx['condition']) {
      let b4 = block4();
      let b5 = block5();
      b3 = multi([b4, b5]);
    }
    return block1([], [b2, b3]);
  }
}"
`;