owl/tests/components/__snapshots__/rendering.test.ts.snap

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

exports[`children, default props and renderings 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(ctx['state'].value);
    const b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
    return multi([b2, b3]);
  }
}"
`;

exports[`children, default props and renderings 2`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(\`child\`);
  }
}"
`;

exports[`force render in case of existing render 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`B\`, {val: ctx['state'].val}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`force render in case of existing render 2`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = component(\`C\`, {}, key + \`__1\`, node, ctx);
    const b3 = text(ctx['props'].val);
    return multi([b2, b3]);
  }
}"
`;

exports[`force render in case of existing render 3`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(\`C\`);
  }
}"
`;

exports[`rendering semantics can force a render to update sub tree 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(ctx['state'].value);
    const b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
    return multi([b2, b3]);
  }
}"
`;

exports[`rendering semantics can force a render to update sub tree 2`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(\`child\`);
  }
}"
`;

exports[`rendering semantics can render a parent without rendering child 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(ctx['state'].value);
    const b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
    return multi([b2, b3]);
  }
}"
`;

exports[`rendering semantics can render a parent without rendering child 2`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(\`child\`);
  }
}"
`;

exports[`rendering semantics props are reactive (nested prop) 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {a: ctx['state']}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`rendering semantics props are reactive (nested prop) 2`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(ctx['props'].a.b.c);
  }
}"
`;

exports[`rendering semantics props are reactive 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, {a: ctx['state']}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`rendering semantics props are reactive 2`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(ctx['props'].a.b);
  }
}"
`;

exports[`rendering semantics render need a boolean = true to be 'deep' 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(ctx['state'].value);
    const b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
    return multi([b2, b3]);
  }
}"
`;

exports[`rendering semantics render need a boolean = true to be 'deep' 2`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(\`child\`);
  }
}"
`;

exports[`rendering semantics render with deep=true followed by render with deep=false work as expected 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`parent\`);
    const b3 = text(ctx['state'].value);
    const b4 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
    return multi([b2, b3, b4]);
  }
}"
`;

exports[`rendering semantics render with deep=true followed by render with deep=false work as expected 2`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(\`child\`);
    const b3 = text(ctx['env'].getValue());
    return multi([b2, b3]);
  }
}"
`;

exports[`rendering semantics rendering is atomic (for one subtree) 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    const b2 = text(ctx['state'].obj.val);
    const b3 = component(\`B\`, {obj: ctx['state'].obj}, key + \`__1\`, node, ctx);
    return multi([b2, b3]);
  }
}"
`;

exports[`rendering semantics rendering is atomic (for one subtree) 2`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`C\`, {obj: ctx['props'].obj}, key + \`__1\`, node, ctx);
  }
}"
`;

exports[`rendering semantics rendering is atomic (for one subtree) 3`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(ctx['props'].obj.val);
  }
}"
`;

exports[`rendering semantics works as expected for dynamic number of props 1`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return component(\`Child\`, Object.assign({}, ctx['state']), key + \`__1\`, node, ctx);
  }
}"
`;

exports[`rendering semantics works as expected for dynamic number of props 2`] = `
"function anonymous(app, bdom, helpers
) {
  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
  
  return function template(ctx, node, key = \\"\\") {
    return text(Object.keys(ctx['props']).length);
  }
}"
`;