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

exports[`basics accept ES6-like syntax for props (with getters) 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`Child\`, {greetings: ctx['greetings']}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`basics accept ES6-like syntax for props (with getters) 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-text-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].greetings;
    return block1([txt1]);
  }
}"
`;

exports[`basics arrow functions as prop correctly capture their scope 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { prepareList, withKey } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['items']);
    for (let i1 = 0; i1 < l_block1; i1++) {
      ctx[\`item\`] = v_block1[i1];
      let key1 = ctx['item'].val;
      const v1 = ctx['onClick'];
      const v2 = ctx['item'];
      c_block1[i1] = withKey(component(\`Child\`, {onClick: _ev=>v1(v2.val,_ev)}, key + \`__1__\${key1}\`, node, ctx), key1);
    }
    return list(c_block1);
  }
}"
`;

exports[`basics arrow functions as prop correctly capture their scope 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<button block-handler-0=\\"click\\"/>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let hdlr1 = [ctx['props'].onClick, ctx];
    return block1([hdlr1]);
  }
}"
`;

exports[`basics explicit object prop 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let b2 = component(\`Child\`, {value: ctx['state'].val}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`basics explicit object prop 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-text-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['state'].someval;
    return block1([txt1]);
  }
}"
`;

exports[`basics prop names can contain - 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {'prop-name': 7}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`basics prop names can contain - 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<div><block-text-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props']['prop-name'];
    return block1([txt1]);
  }
}"
`;

exports[`basics support prop names that aren't valid bare object property names 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {'some-dashed-prop': 5}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`basics support prop names that aren't valid bare object property names 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<button block-handler-0=\\"click\\"/>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let hdlr1 = [ctx['props'].onClick, ctx];
    return block1([hdlr1]);
  }
}"
`;

exports[`basics t-set with a body expression can be passed in props, and then t-out 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { isBoundary, withDefault, LazyValue } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  let block2 = createBlock(\`<p>43</p>\`);
  
  function value1(ctx, node, key = \\"\\") {
    return block2();
  }
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1
    ctx[\`abc\`] = new LazyValue(value1, ctx, node);
    let b3 = component(\`Child\`, {val: ctx['abc']}, key + \`__1\`, node, ctx);
    return block1([], [b3]);
  }
}"
`;

exports[`basics t-set with a body expression can be passed in props, and then t-out 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { safeOutput } = helpers;
  
  let block1 = createBlock(\`<span><block-text-0/><block-child-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].val;
    let b2 = safeOutput(ctx['props'].val);
    return block1([txt1], [b2]);
  }
}"
`;

exports[`basics t-set with a body expression can be used as textual prop 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { isBoundary, withDefault, setContextValue } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1
    setContextValue(ctx, \\"abc\\", \`42\`);
    let b2 = component(\`Child\`, {val: ctx['abc']}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`basics t-set with a body expression can be used as textual prop 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-text-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].val;
    return block1([txt1]);
  }
}"
`;

exports[`basics t-set works  1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { isBoundary, withDefault, setContextValue } = helpers;
  
  let block1 = createBlock(\`<div><block-child-0/></div>\`);
  
  return function template(ctx, node, key = \\"\\") {
    ctx = Object.create(ctx);
    ctx[isBoundary] = 1
    setContextValue(ctx, \\"val\\", 42);
    let b2 = component(\`Child\`, {val: ctx['val']}, key + \`__1\`, node, ctx);
    return block1([], [b2]);
  }
}"
`;

exports[`basics t-set works  2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  let block1 = createBlock(\`<span><block-text-0/></span>\`);
  
  return function template(ctx, node, key = \\"\\") {
    let txt1 = ctx['props'].val;
    return block1([txt1]);
  }
}"
`;

exports[`basics template string in prop 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {propName: \`1\${ctx['someVal']}3\`}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`basics template string in prop 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(\`\`);
  }
}"
`;

exports[`bound functions is referentially equal after update 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { bind } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {val: ctx['state'].val, fn: bind(ctx, ctx['someFunction'])}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`bound functions is referentially equal after update 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(ctx['props'].val);
  }
}"
`;

exports[`can bind function prop with bind suffix 1`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  let { bind } = helpers;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {doSomething: bind(ctx, ctx['doSomething'])}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`can bind function prop with bind suffix 2`] = `
"function anonymous(bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(\`child\`);
  }
}"
`;