[IMP] .gitignore: ignore tools/devtools build folder

Otherwise, it is annoying to have build files that should never be
committed anyway

.gitignore

@@ -22,6 +22,7 @@ node_modules
 
 # Extras temp file
 /tools/owl.js
+/tools/devtools/build
 
 release-notes.md
 

src/compiler/code_generator.ts

@@ -1,4 +1,3 @@
-import { isProp } from "../runtime/blockdom/attributes";
 import {
   compileExpr,
   compileExprToArray,
@@ -15,7 +14,6 @@ import {
   ASTLog,
   ASTMulti,
   ASTSlot,
-  ASTSlotDefinition,
   ASTTCall,
   ASTTCallBlock,
   ASTTEsc,
@@ -59,6 +57,30 @@ function generateId(prefix: string = "") {
   return prefix + nextDataIds[prefix];
 }
 
+function isProp(tag: string, key: string): boolean {
+  switch (tag) {
+    case "input":
+      return (
+        key === "checked" ||
+        key === "indeterminate" ||
+        key === "value" ||
+        key === "readonly" ||
+        key === "readOnly" ||
+        key === "disabled"
+      );
+    case "option":
+      return key === "selected" || key === "disabled";
+    case "textarea":
+      return key === "value" || key === "readonly" || key === "readOnly" || key === "disabled";
+    case "select":
+      return key === "value" || key === "disabled";
+    case "button":
+    case "optgroup":
+      return key === "disabled";
+  }
+  return false;
+}
+
 // -----------------------------------------------------------------------------
 // BlockDescription
 // -----------------------------------------------------------------------------
@@ -138,14 +160,12 @@ interface Context {
   index: number | string;
   forceNewBlock: boolean;
   preventRoot?: boolean;
-  ignoreRoot?: boolean;
   isLast?: boolean;
   translate: boolean;
   tKeyExpr: string | null;
   nameSpace?: string;
   tModelSelectedExpr?: string;
   ctxVar?: string;
-  slotVar?: string;
 }
 
 function createContext(parentCtx: Context, params?: Partial<Context>): Context {
@@ -158,7 +178,6 @@ function createContext(parentCtx: Context, params?: Partial<Context>): Context {
       tKeyExpr: null,
       nameSpace: parentCtx.nameSpace,
       tModelSelectedExpr: parentCtx.tModelSelectedExpr,
-      slotVar: parentCtx.slotVar
     },
     params
   );
@@ -362,7 +381,7 @@ export class CodeGenerator {
   ): BlockDescription {
     const hasRoot = this.target.hasRoot;
     const block = new BlockDescription(this.target, type);
-    if (!hasRoot && !ctx.preventRoot && !ctx.ignoreRoot) {
+    if (!hasRoot && !ctx.preventRoot) {
       this.target.hasRoot = true;
       block.isRoot = true;
     }
@@ -388,9 +407,6 @@ export class CodeGenerator {
       blockExpr = `toggler(${ctx.tKeyExpr}, ${blockExpr})`;
     }
 
-    if (ctx.ignoreRoot) {
-      return;
-    }
     if (block.isRoot && !ctx.preventRoot) {
       if (this.target.on) {
         blockExpr = this.wrapWithEventCatcher(blockExpr, this.target.on);
@@ -472,8 +488,6 @@ export class CodeGenerator {
         return this.compileLog(ast, ctx);
       case ASTType.TSlot:
         return this.compileTSlot(ast, ctx);
-      case ASTType.TSetSlot:
-        return this.compileTSetSlot(ast, ctx);
       case ASTType.TTranslation:
         return this.compileTTranslation(ast, ctx);
       case ASTType.TPortal:
@@ -587,19 +601,26 @@ export class CodeGenerator {
         attrName = key === "t-att" ? null : key.slice(6);
         expr = compileExpr(ast.attrs[key]);
         if (attrName && isProp(ast.tag, attrName)) {
+          if (attrName === "readonly") {
+            // the property has a different name than the attribute
+            attrName = "readOnly";
+          }
           // we force a new string or new boolean to bypass the equality check in blockdom when patching same value
           if (attrName === "value") {
-            // When the expression is falsy, fall back to an empty string
-            expr = `new String((${expr}) || "")`;
+            // When the expression is falsy (except 0), fall back to an empty string
+            expr = `new String((${expr}) === 0 ? 0 : ((${expr}) || ""))`;
           } else {
             expr = `new Boolean(${expr})`;
           }
-        }
-        const idx = block!.insertData(expr, "attr");
-        if (key === "t-att") {
-          attrs[`block-attributes`] = String(idx);
+          const idx = block!.insertData(expr, "prop");
+          attrs[`block-property-${idx}`] = attrName!;
         } else {
-          attrs[`block-attribute-${idx}`] = attrName!;
+          const idx = block!.insertData(expr, "attr");
+          if (key === "t-att") {
+            attrs[`block-attributes`] = String(idx);
+          } else {
+            attrs[`block-attribute-${idx}`] = attrName!;
+          }
         }
       } else if (this.translatableAttributes.includes(key)) {
         attrs[key] = this.translateFn(ast.attrs[key]);
@@ -649,15 +670,15 @@ export class CodeGenerator {
             targetExpr = compileExpr(dynamicTgExpr);
           }
         }
-        idx = block!.insertData(`${fullExpression} === ${targetExpr}`, "attr");
-        attrs[`block-attribute-${idx}`] = specialInitTargetAttr;
+        idx = block!.insertData(`${fullExpression} === ${targetExpr}`, "prop");
+        attrs[`block-property-${idx}`] = specialInitTargetAttr;
       } else if (hasDynamicChildren) {
         const bValueId = generateId("bValue");
         tModelSelectedExpr = `${bValueId}`;
         this.define(tModelSelectedExpr, fullExpression);
       } else {
-        idx = block!.insertData(`${fullExpression}`, "attr");
-        attrs[`block-attribute-${idx}`] = targetAttr;
+        idx = block!.insertData(`${fullExpression}`, "prop");
+        attrs[`block-property-${idx}`] = targetAttr;
       }
       this.helpers.add("toNumber");
       let valueCode = `ev.target.${targetAttr}`;
@@ -1153,38 +1174,52 @@ export class CodeGenerator {
     const props: string[] = ast.props ? this.formatPropObject(ast.props) : [];
 
     // slots
-    let slotVar: string = "";
-    if (ast.body) {
-      slotVar = generateId("slots");
-      this.helpers.add("markRaw");
-      if (ast.body.type === ASTType.TSetSlot) {
-        const subCtx = createContext(ctx, { slotVar: undefined, ignoreRoot: true });
-        const slotInfo = this.compileAST(ast.body, subCtx);
-        this.target.addLine(`let ${slotVar} = markRaw({'${ast.body.name}': ${slotInfo}});`);
-
-      } else {
-        this.target.addLine(`let ${slotVar} = markRaw({});`);
-        const subCtx = createContext(ctx, { slotVar, ignoreRoot: true });
-        this.compileAST(ast.body, subCtx);
+    let slotDef: string = "";
+    if (ast.slots) {
+      let ctxStr = "ctx";
+      if (this.target.loopLevel || !this.hasSafeContext) {
+        ctxStr = generateId("ctx");
+        this.helpers.add("capture");
+        this.define(ctxStr, `capture(ctx)`);
       }
+      let slotStr: string[] = [];
+      for (let slotName in ast.slots) {
+        const slotAst = ast.slots[slotName];
+        const params = [];
+        if (slotAst.content) {
+          const name = this.compileInNewTarget("slot", slotAst.content, ctx, slotAst.on);
+          params.push(`__render: ${name}.bind(this), __ctx: ${ctxStr}`);
+        }
+        const scope = ast.slots[slotName].scope;
+        if (scope) {
+          params.push(`__scope: "${scope}"`);
+        }
+        if (ast.slots[slotName].attrs) {
+          params.push(...this.formatPropObject(ast.slots[slotName].attrs!));
+        }
+        const slotInfo = `{${params.join(", ")}}`;
+        slotStr.push(`'${slotName}': ${slotInfo}`);
+      }
+      slotDef = `{${slotStr.join(", ")}}`;
     }
 
-    if (slotVar && !(ast.dynamicProps || hasSlotsProp)) {
-      props.push(`slots: ${slotVar}`);
+    if (slotDef && !(ast.dynamicProps || hasSlotsProp)) {
+      this.helpers.add("markRaw");
+      props.push(`slots: markRaw(${slotDef})`);
     }
 
     let propString = this.getPropString(props, ast.dynamicProps);
 
     let propVar: string;
-    if ((slotVar && (ast.dynamicProps || hasSlotsProp)) || this.dev) {
+    if ((slotDef && (ast.dynamicProps || hasSlotsProp)) || this.dev) {
       propVar = generateId("props");
       this.define(propVar!, propString);
       propString = propVar!;
     }
 
-    if (slotVar && (ast.dynamicProps || hasSlotsProp)) {
+    if (slotDef && (ast.dynamicProps || hasSlotsProp)) {
       this.helpers.add("markRaw");
-      this.addLine(`${propVar!}.slots = markRaw(Object.assign(${slotVar}, ${propVar!}.slots))`);
+      this.addLine(`${propVar!}.slots = markRaw(Object.assign(${slotDef}, ${propVar!}.slots))`);
     }
 
     // cmap key
@@ -1215,7 +1250,7 @@ export class CodeGenerator {
       id,
       expr: `app.createComponent(${
         ast.isDynamic ? null : expr
-      }, ${!ast.isDynamic}, ${!!ast.body}, ${!!ast.dynamicProps}, ${
+      }, ${!ast.isDynamic}, ${!!ast.slots}, ${!!ast.dynamicProps}, ${
         !ast.props && !ast.dynamicProps
       })`,
     });
@@ -1258,39 +1293,6 @@ export class CodeGenerator {
     return `${name}(${expr}, [${handlers.join(",")}])`;
   }
 
-  compileTSetSlot(ast: ASTSlotDefinition, ctx: Context): string {
-        let ctxStr = "ctx";
-      if (this.target.loopLevel || !this.hasSafeContext) {
-        ctxStr = generateId("ctx");
-        this.helpers.add("capture");
-        this.define(ctxStr, `capture(ctx)`);
-      }
-      // let slotStr: string[] = [];
-      // for (let slotName in ast.slots) {
-        // const slotAst = ast.slots[slotName];
-        const params = [];
-        if (ast.content) {
-          const name = this.compileInNewTarget("slot", ast.content, ctx, ast.on);
-          params.push(`__render: ${name}.bind(this), __ctx: ${ctxStr}`);
-        }
-        // ast.scope
-        // const scope = ast.slots[slotName].scope;
-        if (ast.scope) {
-          params.push(`__scope: "${ast.scope}"`);
-        }
-        if (ast.attrs) {
-          params.push(...this.formatPropObject(ast.attrs!));
-        }
-        const slotInfo = `{${params.join(", ")}}`;
-        if (ctx.slotVar) {
-          this.target.addLine(`${ctx.slotVar}['${ast.name}'] = ${slotInfo};`)
-        }
-        // slotStr.push(`'${slotName}': ${slotInfo}`);
-      // }
-      // slotDef = `{${slotStr.join(", ")}}`;
-    return slotInfo;
-  }
-
   compileTSlot(ast: ASTSlot, ctx: Context): string {
     this.helpers.add("callSlot");
     let { block } = ctx;

src/compiler/parser.ts

@@ -23,7 +23,6 @@ export const enum ASTType {
   TDebug,
   TLog,
   TSlot,
-  TSetSlot,
   TCallBlock,
   TTranslation,
   TPortal,
@@ -121,9 +120,7 @@ export interface ASTTCall {
   context: string | null;
 }
 
-export interface ASTSlotDefinition {
-  type: ASTType.TSetSlot;
-  name: string;
+interface SlotDefinition {
   content: AST | null;
   scope: string | null;
   on: EventHandlers | null;
@@ -137,8 +134,7 @@ export interface ASTComponent {
   dynamicProps: string | null;
   on: EventHandlers | null;
   props: { [name: string]: string } | null;
-  body: AST | null;
-  // slots: { [name: string]: ASTSlotDefinition } | null;
+  slots: { [name: string]: SlotDefinition } | null;
 }
 
 export interface ASTSlot {
@@ -190,7 +186,6 @@ export type AST =
   | ASTTKey
   | ASTComponent
   | ASTSlot
-  | ASTSlotDefinition
   | ASTTCallBlock
   | ASTLog
   | ASTDebug
@@ -243,7 +238,6 @@ function parseNode(node: Node, ctx: ParsingContext): AST | null {
     parseTKey(node, ctx) ||
     parseTTranslation(node, ctx) ||
     parseTSlot(node, ctx) ||
-    parseTSetSlot(node, ctx) ||
     parseTOutNode(node, ctx) ||
     parseComponent(node, ctx) ||
     parseDOMNode(node, ctx) ||
@@ -579,12 +573,12 @@ function parseTCall(node: Element, ctx: ParsingContext): AST | null {
       ast.content = [tcall];
       return ast;
     }
-    // if (ast && ast.type === ASTType.TComponent) {
-    //   return {
-    //     ...ast,
-    //     slots: { default: { content: tcall, scope: null, on: null, attrs: null } },
-    //   };
-    // }
+    if (ast && ast.type === ASTType.TComponent) {
+      return {
+        ...ast,
+        slots: { default: { content: tcall, scope: null, on: null, attrs: null } },
+      };
+    }
   }
   const body = parseChildren(node, ctx);
 
@@ -712,8 +706,8 @@ function parseComponent(node: Element, ctx: ParsingContext): AST | null {
   const dynamicProps = node.getAttribute("t-props");
   node.removeAttribute("t-props");
 
-  // const defaultSlotScope = node.getAttribute("t-slot-scope");
-  // node.removeAttribute("t-slot-scope");
+  const defaultSlotScope = node.getAttribute("t-slot-scope");
+  node.removeAttribute("t-slot-scope");
   let on: ASTComponent["on"] = null;
 
   let props: ASTComponent["props"] = null;
@@ -733,17 +727,67 @@ function parseComponent(node: Element, ctx: ParsingContext): AST | null {
     }
   }
 
-  let body: ASTComponent["body"] = null;
-
-  // let slots: ASTComponent["slots"] | null = null;
+  let slots: ASTComponent["slots"] | null = null;
   if (node.hasChildNodes()) {
-    body = parseChildNodes(node, ctx);
-    if (!node.querySelector('[t-set-slot]')) {
-      body = {type: ASTType.TSetSlot, name: "default", content: body, on: null, attrs: null, scope: null}
+    const clone = <Element>node.cloneNode(true);
+
+    // named slots
+    const slotNodes = Array.from(clone.querySelectorAll("[t-set-slot]"));
+    for (let slotNode of slotNodes) {
+      if (slotNode.tagName !== "t") {
+        throw new OwlError(
+          `Directive 't-set-slot' can only be used on <t> nodes (used on a <${slotNode.tagName}>)`
+        );
+      }
+      const name = slotNode.getAttribute("t-set-slot")!;
+
+      // check if this is defined in a sub component (in which case it should
+      // be ignored)
+      let el = slotNode.parentElement!;
+      let isInSubComponent = false;
+      while (el !== clone) {
+        if (el!.hasAttribute("t-component") || el!.tagName[0] === el!.tagName[0].toUpperCase()) {
+          isInSubComponent = true;
+          break;
+        }
+        el = el.parentElement!;
+      }
+      if (isInSubComponent) {
+        continue;
+      }
+
+      slotNode.removeAttribute("t-set-slot");
+      slotNode.remove();
+      const slotAst = parseNode(slotNode, ctx);
+      let on: SlotDefinition["on"] = null;
+      let attrs: Attrs | null = null;
+      let scope: string | null = null;
+      for (let attributeName of slotNode.getAttributeNames()) {
+        const value = slotNode.getAttribute(attributeName)!;
+        if (attributeName === "t-slot-scope") {
+          scope = value;
+          continue;
+        } else if (attributeName.startsWith("t-on-")) {
+          on = on || {};
+          on[attributeName.slice(5)] = value;
+        } else {
+          attrs = attrs || {};
+          attrs[attributeName] = value;
+        }
+      }
+      slots = slots || {};
+      slots[name] = { content: slotAst, on, attrs, scope };
     }
 
+    // default slot
+    const defaultContent = parseChildNodes(clone, ctx);
+    slots = slots || {};
+    // t-set-slot="default" has priority over content
+    if (defaultContent && !slots.default) {
+      slots.default = { content: defaultContent, on, attrs: null, scope: defaultSlotScope };
+    }
   }
-  return { type: ASTType.TComponent, name, isDynamic, dynamicProps, props, body, on };
+  return { type: ASTType.TComponent, name, isDynamic, dynamicProps, props, slots, on };
 }
 
 // -----------------------------------------------------------------------------
@@ -777,71 +821,6 @@ function parseTSlot(node: Element, ctx: ParsingContext): AST | null {
   };
 }
 
-function parseTSetSlot(node: Element, ctx: ParsingContext): AST | null {
-  if (!node.hasAttribute("t-set-slot")) {
-    return null;
-  }
-  // const t = el.ownerDocument.createElement("t");
-
-    // const clone = <Element>node.cloneNode(true);
-
-    // // named slots
-    // const slotNodes = Array.from(clone.querySelectorAll("[t-set-slot]"));
-    // for (let slotNode of slotNodes) {
-      if (node.tagName !== "t") {
-        throw new OwlError(
-          `Directive 't-set-slot' can only be used on <t> nodes (used on a <${node.tagName}>)`
-        );
-      }
-      const name = node.getAttribute("t-set-slot")!;
-
-    //   // check if this is defined in a sub component (in which case it should
-    //   // be ignored)
-    //   let el = slotNode.parentElement!;
-    //   let isInSubComponent = false;
-    //   while (el !== clone) {
-    //     if (el!.hasAttribute("t-component") || el!.tagName[0] === el!.tagName[0].toUpperCase()) {
-    //       isInSubComponent = true;
-    //       break;
-    //     }
-    //     el = el.parentElement!;
-    //   }
-    //   if (isInSubComponent) {
-    //     continue;
-    //   }
-
-      node.removeAttribute("t-set-slot");
-      node.remove();
-      const slotAst = parseNode(node, ctx);
-      let on: ASTSlotDefinition["on"] = null;
-      let attrs: Attrs | null = null;
-      let scope: string | null = null;
-      for (let attributeName of node.getAttributeNames()) {
-        const value = node.getAttribute(attributeName)!;
-        if (attributeName === "t-slot-scope") {
-          scope = value;
-          continue;
-        } else if (attributeName.startsWith("t-on-")) {
-          on = on || {};
-          on[attributeName.slice(5)] = value;
-        } else {
-          attrs = attrs || {};
-          attrs[attributeName] = value;
-        }
-      }
-    //   slots = slots || {};
-      return { type: ASTType.TSetSlot, name, content: slotAst, on, attrs, scope };
-    // }
-
-    // // default slot
-    // const defaultContent = parseChildNodes(clone, ctx);
-    // slots = slots || {};
-    // // t-set-slot="default" has priority over content
-    // if (defaultContent && !slots.default) {
-    //   slots.default = { content: defaultContent, on, attrs: null, scope: defaultSlotScope };
-    // }
-}
-
 function parseTTranslation(node: Element, ctx: ParsingContext): AST | null {
   if (node.getAttribute("t-translation") !== "off") {
     return null;

src/runtime/blockdom/attributes.ts

@@ -140,33 +140,3 @@ export function updateClass(this: HTMLElement, val: any, oldVal: any) {
     }
   }
 }
-
-export function makePropSetter(name: string): Setter<HTMLElement> {
-  return function setProp(this: HTMLElement, value: any) {
-    // support 0, fallback to empty string for other falsy values
-    (this as any)[name] = value === 0 ? 0 : value ? value.valueOf() : "";
-  };
-}
-
-export function isProp(tag: string, key: string): boolean {
-  switch (tag) {
-    case "input":
-      return (
-        key === "checked" ||
-        key === "indeterminate" ||
-        key === "value" ||
-        key === "readonly" ||
-        key === "disabled"
-      );
-    case "option":
-      return key === "selected" || key === "disabled";
-    case "textarea":
-      return key === "value" || key === "readonly" || key === "disabled";
-    case "select":
-      return key === "value" || key === "disabled";
-    case "button":
-    case "optgroup":
-      return key === "disabled";
-  }
-  return false;
-}

src/runtime/blockdom/block_compiler.ts

@@ -1,13 +1,5 @@
 import { OwlError } from "../error_handling";
-import {
-  attrsSetter,
-  attrsUpdater,
-  createAttrUpdater,
-  isProp,
-  makePropSetter,
-  setClass,
-  updateClass,
-} from "./attributes";
+import { attrsSetter, attrsUpdater, createAttrUpdater, setClass, updateClass } from "./attributes";
 import { config } from "./config";
 import { createEventHandler } from "./events";
 import type { VNode } from "./index";
@@ -25,6 +17,13 @@ const nodeGetNextSibling = getDescriptor(nodeProto, "nextSibling").get!;
 
 const NO_OP = () => {};
 
+function makePropSetter(name: string): Setter<HTMLElement> {
+  return function setProp(this: HTMLElement, value: any) {
+    // support 0, fallback to empty string for other falsy values
+    (this as any)[name] = value === 0 ? 0 : value ? value.valueOf() : "";
+  };
+}
+
 // -----------------------------------------------------------------------------
 // Main compiler code
 // -----------------------------------------------------------------------------
@@ -101,7 +100,7 @@ function normalizeNode(node: HTMLElement | Text) {
 interface DynamicInfo {
   idx: number;
   refIdx?: number;
-  type: "text" | "child" | "handler" | "attribute" | "attributes" | "ref";
+  type: "text" | "child" | "handler" | "attribute" | "attributes" | "property" | "ref";
   isOnlyChild?: boolean;
   name?: string;
   tag?: string;
@@ -184,6 +183,14 @@ function buildTree(
               name: attrValue,
               tag: tagName,
             });
+          } else if (attrName.startsWith("block-property-")) {
+            const idx = parseInt(attrName.slice(15), 10);
+            info.push({
+              type: "property",
+              idx,
+              name: attrValue,
+              tag: tagName,
+            });
           } else if (attrName === "block-attributes") {
             info.push({
               type: "attributes",
@@ -377,15 +384,22 @@ function updateCtx(ctx: BlockCtx, tree: IntermediateTree) {
           };
         }
         break;
+      case "property": {
+        const refIdx = info.refIdx!;
+        const setProp = makePropSetter(info.name!);
+        ctx.locations.push({
+          idx: info.idx,
+          refIdx,
+          setData: setProp,
+          updateData: setProp,
+        });
+        break;
+      }
       case "attribute": {
         const refIdx = info.refIdx!;
         let updater: any;
         let setter: any;
-        if (isProp(info.tag!, info.name!)) {
-          const setProp = makePropSetter(info.name!);
-          setter = setProp;
-          updater = setProp;
-        } else if (info.name === "class") {
+        if (info.name === "class") {
           setter = setClass;
           updater = updateClass;
         } else {

tests/blockdom/block_attributes.test.ts

@@ -145,59 +145,3 @@ test("class attribute (with a preexisting value", async () => {
   patch(tree, block([""]));
   expect(fixture.innerHTML).toBe(`<div class="tomato"></div>`);
 });
-
-describe("properties", () => {
-  test("input with value attribute", () => {
-    // render input with initial value
-    const block = createBlock(`<input block-attribute-0="value"/>`);
-
-    const tree = block(["zucchini"]);
-    mount(tree, fixture);
-    // const bnode1 = renderToBdom(template, { v: "zucchini" });
-    // const fixture = makeTestFixture();
-    // mount(bnode1, fixture);
-    const input = fixture.querySelector("input")!;
-    expect(input.value).toBe("zucchini");
-
-    // change value manually in input, to simulate user input
-    input.value = "tomato";
-    expect(input.value).toBe("tomato");
-
-    // rerender with a different value, and patch actual dom, to check that
-    // input value was properly reset by owl
-    patch(tree, block(["potato"]));
-    expect(input.value).toBe("potato");
-  });
-
-  test("input with value attribute, and falsy value given", () => {
-    const block = createBlock(`<input block-attribute-0="value"/>`);
-
-    const tree = block([undefined]);
-    mount(tree, fixture);
-    const input = fixture.querySelector("input")!;
-    expect(input.value).toBe("");
-
-    patch(tree, block([null]));
-    expect(input.value).toBe("");
-
-    patch(tree, block([0]));
-    expect(input.value).toBe("0");
-
-    patch(tree, block([""]));
-    expect(input.value).toBe("");
-
-    patch(tree, block([false]));
-    expect(input.value).toBe("");
-  });
-
-  test("input type=checkbox with checked attribute", () => {
-    // render input with initial value
-    const block = createBlock(`<input type="checkbox" block-attribute-0="checked"/>`);
-
-    const tree = block([true]);
-    mount(tree, fixture);
-    expect(fixture.innerHTML).toBe(`<input type="checkbox">`);
-    const input = fixture.querySelector("input")!;
-    expect(input.checked).toBe(true);
-  });
-});

tests/blockdom/block_properties.test.ts

@@ -0,0 +1,70 @@
+import { mount, patch, createBlock } from "../../src/runtime/blockdom";
+import { makeTestFixture } from "./helpers";
+
+//------------------------------------------------------------------------------
+// Setup and helpers
+//------------------------------------------------------------------------------
+
+let fixture: HTMLElement;
+
+beforeEach(() => {
+  fixture = makeTestFixture();
+});
+
+afterEach(() => {
+  fixture.remove();
+});
+
+test("input with value property", () => {
+  // render input with initial value
+  const block = createBlock(`<input block-property-0="value"/>`);
+
+  const tree = block(["zucchini"]);
+  mount(tree, fixture);
+  // const bnode1 = renderToBdom(template, { v: "zucchini" });
+  // const fixture = makeTestFixture();
+  // mount(bnode1, fixture);
+  const input = fixture.querySelector("input")!;
+  expect(input.value).toBe("zucchini");
+
+  // change value manually in input, to simulate user input
+  input.value = "tomato";
+  expect(input.value).toBe("tomato");
+
+  // rerender with a different value, and patch actual dom, to check that
+  // input value was properly reset by owl
+  patch(tree, block(["potato"]));
+  expect(input.value).toBe("potato");
+});
+
+test("input with value property, and falsy value given", () => {
+  const block = createBlock(`<input block-property-0="value"/>`);
+
+  const tree = block([undefined]);
+  mount(tree, fixture);
+  const input = fixture.querySelector("input")!;
+  expect(input.value).toBe("");
+
+  patch(tree, block([null]));
+  expect(input.value).toBe("");
+
+  patch(tree, block([0]));
+  expect(input.value).toBe("0");
+
+  patch(tree, block([""]));
+  expect(input.value).toBe("");
+
+  patch(tree, block([false]));
+  expect(input.value).toBe("");
+});
+
+test("input type=checkbox with checked property", () => {
+  // render input with initial value
+  const block = createBlock(`<input type="checkbox" block-property-0="checked"/>`);
+
+  const tree = block([true]);
+  mount(tree, fixture);
+  expect(fixture.innerHTML).toBe(`<input type="checkbox">`);
+  const input = fixture.querySelector("input")!;
+  expect(input.checked).toBe(true);
+});

tests/compiler/__snapshots__/attributes.test.ts.snap

@@ -28,20 +28,6 @@ exports[`attributes changing a class with t-att-class 1`] = `
 }"
 `;
 
-exports[`attributes changing an attribute with t-att- 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div block-attribute-0=\\"value\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['v'];
-    return block1([attr1]);
-  }
-}"
-`;
-
 exports[`attributes class and t-att-class should combine together 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -721,20 +707,6 @@ exports[`attributes updating classes (with obj notation) 1`] = `
 }"
 `;
 
-exports[`attributes updating property with falsy value 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<input block-attribute-0=\\"value\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let attr1 = new String((ctx['v']) || \\"\\");
-    return block1([attr1]);
-  }
-}"
-`;
-
 exports[`attributes various escapes 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -763,114 +735,3 @@ exports[`attributes various escapes 2 1`] = `
   }
 }"
 `;
-
-exports[`special cases for some specific html attributes/properties input of type checkbox with t-att-indeterminate 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<input type=\\"checkbox\\" block-attribute-0=\\"indeterminate\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let attr1 = new Boolean(ctx['v']);
-    return block1([attr1]);
-  }
-}"
-`;
-
-exports[`special cases for some specific html attributes/properties input type= checkbox, with t-att-checked 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<input type=\\"checkbox\\" block-attribute-0=\\"checked\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let attr1 = new Boolean(ctx['flag']);
-    return block1([attr1]);
-  }
-}"
-`;
-
-exports[`special cases for some specific html attributes/properties input with t-att-value (patching with same value 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<input block-attribute-0=\\"value\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let attr1 = new String((ctx['v']) || \\"\\");
-    return block1([attr1]);
-  }
-}"
-`;
-
-exports[`special cases for some specific html attributes/properties input with t-att-value 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<input block-attribute-0=\\"value\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let attr1 = new String((ctx['v']) || \\"\\");
-    return block1([attr1]);
-  }
-}"
-`;
-
-exports[`special cases for some specific html attributes/properties input, type checkbox, with t-att-checked (patching with same value 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<input type=\\"checkbox\\" block-attribute-0=\\"checked\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let attr1 = new Boolean(ctx['v']);
-    return block1([attr1]);
-  }
-}"
-`;
-
-exports[`special cases for some specific html attributes/properties select with t-att-value 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<select block-attribute-0=\\"value\\"><option value=\\"potato\\">Potato</option><option value=\\"tomato\\">Tomato</option><option value=\\"onion\\">Onion</option></select>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let attr1 = new String((ctx['value']) || \\"\\");
-    return block1([attr1]);
-  }
-}"
-`;
-
-exports[`special cases for some specific html attributes/properties textarea with t-att-value 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<textarea block-attribute-0=\\"value\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let attr1 = new String((ctx['v']) || \\"\\");
-    return block1([attr1]);
-  }
-}"
-`;
-
-exports[`special cases for some specific html attributes/properties various boolean html attributes 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div><input type=\\"checkbox\\" checked=\\"checked\\"/><input checked=\\"checked\\"/><div checked=\\"checked\\"/><div selected=\\"selected\\"/><option selected=\\"selected\\" other=\\"1\\"/><input readonly=\\"readonly\\"/><button disabled=\\"disabled\\"/></div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;

tests/compiler/__snapshots__/misc.test.ts.snap

@@ -187,7 +187,7 @@ exports[`misc other complex template 1`] = `
   const comp1 = app.createComponent(\`BundlesList\`, true, false, false, false);
   const comp2 = app.createComponent(\`BundlesList\`, true, false, false, false);
   
-  let block1 = createBlock(\`<div><header><nav class=\\"navbar navbar-expand-md navbar-light bg-light\\"><a block-attribute-0=\\"href\\"><b style=\\"color:#777;\\"><block-text-1/></b></a><button type=\\"button\\" class=\\"navbar-toggler\\" data-toggle=\\"collapse\\" data-target=\\"#top_menu_collapse\\"><span class=\\"navbar-toggler-icon\\"/></button><div class=\\"collapse navbar-collapse\\" id=\\"top_menu_collapse\\" aria-expanded=\\"false\\"><ul class=\\"nav navbar-nav ml-auto text-right\\" id=\\"top_menu\\"><block-child-0/><li class=\\"nav-item divider\\"/><block-child-1/></ul><div><div class=\\"input-group input-group-sm\\"><div class=\\"input-group-prepend input-group-sm\\"><button class=\\"btn btn-default fa fa-cog\\" title=\\"Settings\\" block-handler-2=\\"click\\"/><button class=\\"btn btn-default\\" block-handler-3=\\"click\\"> More </button><block-child-2/></div><input class=\\"form-control\\" type=\\"text\\" placeholder=\\"Search\\" aria-label=\\"Search\\" name=\\"search\\" block-attribute-4=\\"value\\" block-handler-5=\\"keyup\\" block-handler-6=\\"change\\" block-ref=\\"7\\"/><div class=\\"input-group-append\\"><button class=\\"btn btn-default fa fa-eraser\\" block-handler-8=\\"click\\"/></div></div></div></div></nav></header><div class=\\"container-fluid\\" block-ref=\\"9\\"><div class=\\"row\\"><!--div class=\\"form-group col-md-6\\">
+  let block1 = createBlock(\`<div><header><nav class=\\"navbar navbar-expand-md navbar-light bg-light\\"><a block-attribute-0=\\"href\\"><b style=\\"color:#777;\\"><block-text-1/></b></a><button type=\\"button\\" class=\\"navbar-toggler\\" data-toggle=\\"collapse\\" data-target=\\"#top_menu_collapse\\"><span class=\\"navbar-toggler-icon\\"/></button><div class=\\"collapse navbar-collapse\\" id=\\"top_menu_collapse\\" aria-expanded=\\"false\\"><ul class=\\"nav navbar-nav ml-auto text-right\\" id=\\"top_menu\\"><block-child-0/><li class=\\"nav-item divider\\"/><block-child-1/></ul><div><div class=\\"input-group input-group-sm\\"><div class=\\"input-group-prepend input-group-sm\\"><button class=\\"btn btn-default fa fa-cog\\" title=\\"Settings\\" block-handler-2=\\"click\\"/><button class=\\"btn btn-default\\" block-handler-3=\\"click\\"> More </button><block-child-2/></div><input class=\\"form-control\\" type=\\"text\\" placeholder=\\"Search\\" aria-label=\\"Search\\" name=\\"search\\" block-property-4=\\"value\\" block-handler-5=\\"keyup\\" block-handler-6=\\"change\\" block-ref=\\"7\\"/><div class=\\"input-group-append\\"><button class=\\"btn btn-default fa fa-eraser\\" block-handler-8=\\"click\\"/></div></div></div></div></nav></header><div class=\\"container-fluid\\" block-ref=\\"9\\"><div class=\\"row\\"><!--div class=\\"form-group col-md-6\\">
                       <h5>Search options</h5>
                       <input class=\\"form-control\\" type=\\"text\\" name=\\"default_search\\" id=\\"default_search\\" t-att-checked=\\"default_search\\" placeholder=\\"Default search\\"/>
       
@@ -209,8 +209,8 @@ exports[`misc other complex template 1`] = `
   let block12 = createBlock(\`<li class=\\"nav-item divider\\"/>\`);
   let block13 = createBlock(\`<li class=\\"nav-item dropdown\\"><a href=\\"#\\" class=\\"nav-link dropdown-toggle\\" data-toggle=\\"dropdown\\"><b><span><block-text-0/></span></b></a><div class=\\"dropdown-menu js_usermenu\\" role=\\"menu\\"><a class=\\"dropdown-item\\" id=\\"o_logout\\" role=\\"menuitem\\" block-attribute-1=\\"href\\">Logout</a><a class=\\"dropdown-item\\" role=\\"menuitem\\" block-attribute-2=\\"href\\">Web</a></div></li>\`);
   let block14 = createBlock(\`<select class=\\"custom-select\\" name=\\"category\\" id=\\"category\\"><block-child-0/></select>\`);
-  let block16 = createBlock(\`<option block-attribute-0=\\"value\\" block-attribute-1=\\"selected\\"><block-text-2/></option>\`);
-  let block20 = createBlock(\`<div class=\\"form-check\\"><input class=\\"form-check-input\\" type=\\"checkbox\\" block-attribute-0=\\"name\\" block-attribute-1=\\"id\\" block-attribute-2=\\"checked\\" block-attribute-3=\\"data-trigger_id\\" block-handler-4=\\"change\\"/><label class=\\"form-check-label\\" block-attribute-5=\\"for\\"><block-text-6/></label></div>\`);
+  let block16 = createBlock(\`<option block-attribute-0=\\"value\\" block-property-1=\\"selected\\"><block-text-2/></option>\`);
+  let block20 = createBlock(\`<div class=\\"form-check\\"><input class=\\"form-check-input\\" type=\\"checkbox\\" block-attribute-0=\\"name\\" block-attribute-1=\\"id\\" block-property-2=\\"checked\\" block-attribute-3=\\"data-trigger_id\\" block-handler-4=\\"change\\"/><label class=\\"form-check-label\\" block-attribute-5=\\"for\\"><block-text-6/></label></div>\`);
   let block21 = createBlock(\`<div><button class=\\"btn btn-sm btn-default\\" block-handler-0=\\"click\\">All</button><button class=\\"btn btn-sm btn-default\\" block-handler-1=\\"click\\">None</button><button class=\\"btn btn-sm btn-info\\" block-handler-2=\\"click\\">Default</button><button class=\\"btn btn-sm btn-default\\" block-handler-3=\\"click\\">Close</button></div>\`);
   let block23 = createBlock(\`<div class=\\"alert alert-warning\\" role=\\"alert\\"><block-text-0/> <!-- todo fixme--></div>\`);
   let block24 = createBlock(\`<div class=\\"mb32\\"><h1>No project</h1></div>\`);
@@ -269,15 +269,15 @@ exports[`misc other complex template 1`] = `
         ctx[\`category\`] = v_block15[i1];
         const key1 = ctx['category'].id;
         let attr6 = ctx['category'].id;
-        let attr7 = new Boolean(ctx['category'].id==ctx['options'].active_category_id);
+        let prop1 = new Boolean(ctx['category'].id==ctx['options'].active_category_id);
         let txt5 = ctx['category'].name;
-        c_block15[i1] = withKey(block16([attr6, attr7, txt5]), key1);
+        c_block15[i1] = withKey(block16([attr6, prop1, txt5]), key1);
       }
       ctx = ctx.__proto__;
       const b15 = list(c_block15);
       b14 = block14([], [b15]);
     }
-    let attr8 = new String((ctx['search'].value) || \\"\\");
+    let prop2 = new String((ctx['search'].value) === 0 ? 0 : ((ctx['search'].value) || \\"\\"));
     let hdlr4 = [ctx['updateFilter'], ctx];
     let hdlr5 = [ctx['updateFilter'], ctx];
     let hdlr6 = [ctx['clearSearch'], ctx];
@@ -289,14 +289,14 @@ exports[`misc other complex template 1`] = `
         const key1 = ctx['trigger'].id;
         let b20;
         if (!ctx['trigger'].manual&&ctx['trigger'].project_id===ctx['project'].id&&ctx['trigger'].category_id===ctx['options'].active_category_id) {
-          let attr9 = \`trigger_\${ctx['trigger'].id}\`;
-          let attr10 = \`trigger_\${ctx['trigger'].id}\`;
-          let attr11 = new Boolean(ctx['options'].trigger_display[ctx['trigger'].id]);
-          let attr12 = ctx['trigger'].id;
+          let attr7 = \`trigger_\${ctx['trigger'].id}\`;
+          let attr8 = \`trigger_\${ctx['trigger'].id}\`;
+          let prop3 = new Boolean(ctx['options'].trigger_display[ctx['trigger'].id]);
+          let attr9 = ctx['trigger'].id;
           let hdlr7 = [ctx['updateTriggerDisplay'], ctx];
-          let attr13 = \`trigger_\${ctx['trigger'].id}\`;
+          let attr10 = \`trigger_\${ctx['trigger'].id}\`;
           let txt6 = ctx['trigger'].name;
-          b20 = block20([attr9, attr10, attr11, attr12, hdlr7, attr13, txt6]);
+          b20 = block20([attr7, attr8, prop3, attr9, hdlr7, attr10, txt6]);
         }
         c_block18[i1] = withKey(multi([b20]), key1);
       }
@@ -323,7 +323,7 @@ exports[`misc other complex template 1`] = `
       const b27 = comp2({bundles: ctx['bundles'].dev,search: ctx['search']}, key + \`__3\`, node, this, null);
       b25 = block25([], [b26, b27]);
     }
-    return block1([attr1, txt1, hdlr2, hdlr3, attr8, hdlr4, hdlr5, ref1, hdlr6, ref2], [b2, b4, b14, b17, b22, b23, b24, b25]);
+    return block1([attr1, txt1, hdlr2, hdlr3, prop2, hdlr4, hdlr5, ref1, hdlr6, ref2], [b2, b4, b14, b17, b22, b23, b24, b25]);
   }
 }"
 `;

tests/compiler/__snapshots__/properties.test.ts.snap

@@ -0,0 +1,250 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`changing an attribute with t-att- 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<div block-attribute-0=\\"value\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let attr1 = ctx['v'];
+    return block1([attr1]);
+  }
+}"
+`;
+
+exports[`dynamic input value: falsy values 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<input block-property-0=\\"value\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let prop1 = new String((0) === 0 ? 0 : ((0) || \\"\\"));
+    return block1([prop1]);
+  }
+}"
+`;
+
+exports[`dynamic input value: falsy values 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<input block-property-0=\\"value\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let prop1 = new String((false) === 0 ? 0 : ((false) || \\"\\"));
+    return block1([prop1]);
+  }
+}"
+`;
+
+exports[`dynamic input value: falsy values 3`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<input block-property-0=\\"value\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let prop1 = new String((undefined) === 0 ? 0 : ((undefined) || \\"\\"));
+    return block1([prop1]);
+  }
+}"
+`;
+
+exports[`dynamic input value: falsy values 4`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<input block-property-0=\\"value\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let prop1 = new String(('') === 0 ? 0 : (('') || \\"\\"));
+    return block1([prop1]);
+  }
+}"
+`;
+
+exports[`input of type checkbox with t-att-indeterminate 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<input type=\\"checkbox\\" block-property-0=\\"indeterminate\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let prop1 = new Boolean(ctx['v']);
+    return block1([prop1]);
+  }
+}"
+`;
+
+exports[`input type= checkbox, with t-att-checked 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<input type=\\"checkbox\\" block-property-0=\\"checked\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let prop1 = new Boolean(ctx['flag']);
+    return block1([prop1]);
+  }
+}"
+`;
+
+exports[`input with t-att-value (patching with same value 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<input block-property-0=\\"value\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let prop1 = new String((ctx['v']) === 0 ? 0 : ((ctx['v']) || \\"\\"));
+    return block1([prop1]);
+  }
+}"
+`;
+
+exports[`input with t-att-value 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<input block-property-0=\\"value\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let prop1 = new String((ctx['v']) === 0 ? 0 : ((ctx['v']) || \\"\\"));
+    return block1([prop1]);
+  }
+}"
+`;
+
+exports[`input, type checkbox, with t-att-checked (patching with same value 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<input type=\\"checkbox\\" block-property-0=\\"checked\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let prop1 = new Boolean(ctx['v']);
+    return block1([prop1]);
+  }
+}"
+`;
+
+exports[`readonly and readOnly are both interpreted as the readOnly property 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<input readonly=\\"\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return block1();
+  }
+}"
+`;
+
+exports[`readonly and readOnly are both interpreted as the readOnly property 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<input readOnly=\\"\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return block1();
+  }
+}"
+`;
+
+exports[`readonly and readOnly are both interpreted as the readOnly property 3`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<input block-property-0=\\"readOnly\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let prop1 = new Boolean(ctx['val']);
+    return block1([prop1]);
+  }
+}"
+`;
+
+exports[`readonly and readOnly are both interpreted as the readOnly property 4`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<input block-property-0=\\"readOnly\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let prop1 = new Boolean(ctx['val']);
+    return block1([prop1]);
+  }
+}"
+`;
+
+exports[`select with t-att-value 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<select block-property-0=\\"value\\"><option value=\\"potato\\">Potato</option><option value=\\"tomato\\">Tomato</option><option value=\\"onion\\">Onion</option></select>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let prop1 = new String((ctx['value']) === 0 ? 0 : ((ctx['value']) || \\"\\"));
+    return block1([prop1]);
+  }
+}"
+`;
+
+exports[`textarea with t-att-value 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<textarea block-property-0=\\"value\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let prop1 = new String((ctx['v']) === 0 ? 0 : ((ctx['v']) || \\"\\"));
+    return block1([prop1]);
+  }
+}"
+`;
+
+exports[`updating property with falsy value 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<input block-property-0=\\"value\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let prop1 = new String((ctx['v']) === 0 ? 0 : ((ctx['v']) || \\"\\"));
+    return block1([prop1]);
+  }
+}"
+`;
+
+exports[`various boolean html attributes 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<div><input type=\\"checkbox\\" checked=\\"checked\\"/><input checked=\\"checked\\"/><div checked=\\"checked\\"/><div selected=\\"selected\\"/><option selected=\\"selected\\" other=\\"1\\"/><input readonly=\\"readonly\\"/><button disabled=\\"disabled\\"/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return block1();
+  }
+}"
+`;

tests/compiler/attributes.test.ts

@@ -315,54 +315,6 @@ describe("attributes", () => {
     ).toBe('<div class="a b d"></div>');
   });
 
-  test("changing an attribute with t-att-", () => {
-    // render input with initial value
-    const template = `<div t-att-value="v"/>`;
-    const bnode1 = renderToBdom(template, { v: "zucchini" });
-    const fixture = makeTestFixture();
-    mount(bnode1, fixture);
-
-    expect(fixture.innerHTML).toBe('<div value="zucchini"></div>');
-
-    const bnode2 = renderToBdom(template, { v: "potato" });
-    patch(bnode1, bnode2);
-    expect(fixture.innerHTML).toBe('<div value="potato"></div>');
-
-    const bnode3 = renderToBdom(template, { v: "" });
-    patch(bnode1, bnode3);
-    // not sure about this. maybe we want to remove the attribute?
-    expect(fixture.innerHTML).toBe('<div value=""></div>');
-  });
-
-  test("updating property with falsy value", async () => {
-    // render input with initial value
-    const template = `<input t-att-value="v"></input>`;
-    const bnode1 = renderToBdom(template, { v: false });
-    const fixture = makeTestFixture();
-    mount(bnode1, fixture);
-
-    const input = fixture.querySelector("input")!;
-    expect(input.value).toBe("");
-
-    patch(bnode1, renderToBdom(template, { v: "owl" }));
-    expect(input.value).toBe("owl");
-
-    patch(bnode1, renderToBdom(template, { v: false }));
-    expect(input.value).toBe("");
-
-    patch(bnode1, renderToBdom(template, { v: "owl" }));
-    expect(input.value).toBe("owl");
-
-    patch(bnode1, renderToBdom(template, { v: undefined }));
-    expect(input.value).toBe("");
-
-    patch(bnode1, renderToBdom(template, { v: "owl" }));
-    expect(input.value).toBe("owl");
-
-    patch(bnode1, renderToBdom(template, { v: null }));
-    expect(input.value).toBe("");
-  });
-
   test("changing a class with t-att-class", () => {
     // render input with initial value
     const template = `<div t-att-class="v"/>`;
@@ -420,134 +372,3 @@ describe("attributes", () => {
     expect(fixture.innerHTML).toBe('<div class="hoy a b"></div>');
   });
 });
-
-describe("special cases for some specific html attributes/properties", () => {
-  test("input type= checkbox, with t-att-checked", () => {
-    const template = `<input type="checkbox" t-att-checked="flag"/>`;
-    const result = renderToString(template, { flag: true });
-    expect(result).toBe(`<input type="checkbox">`);
-  });
-
-  test("various boolean html attributes", () => {
-    // will cause the template to be snapshotted
-    renderToString(`
-      <div>
-        <input type="checkbox" checked="checked"/>
-        <input checked="checked"/>
-        <div checked="checked"/>
-        <div selected="selected"/>
-        <option selected="selected" other="1"/>
-        <input readonly="readonly"/>
-        <button disabled="disabled"/>
-      </div>
-      `);
-  });
-
-  test("input with t-att-value", () => {
-    // render input with initial value
-    const template = `<input  t-att-value="v"/>`;
-    const bnode1 = renderToBdom(template, { v: "zucchini" });
-    const fixture = makeTestFixture();
-    mount(bnode1, fixture);
-    const input = fixture.querySelector("input")!;
-    expect(input.value).toBe("zucchini");
-
-    // change value manually in input, to simulate user input
-    input.value = "tomato";
-    expect(input.value).toBe("tomato");
-
-    // rerender with a different value, and patch actual dom, to check that
-    // input value was properly reset by owl
-    const bnode2 = renderToBdom(template, { v: "potato" });
-    patch(bnode1, bnode2);
-    expect(input.value).toBe("potato");
-  });
-
-  test("input with t-att-value (patching with same value", () => {
-    // render input with initial value
-    const template = `<input t-att-value="v"/>`;
-    const bnode1 = renderToBdom(template, { v: "zucchini" });
-    const fixture = makeTestFixture();
-    mount(bnode1, fixture);
-    const input = fixture.querySelector("input")!;
-    expect(input.value).toBe("zucchini");
-
-    // change value manually in input, to simulate user input
-    input.value = "tomato";
-    expect(input.value).toBe("tomato");
-
-    const bnode2 = renderToBdom(template, { v: "zucchini" });
-    patch(bnode1, bnode2);
-    expect(input.value).toBe("zucchini");
-  });
-
-  test("input, type checkbox, with t-att-checked (patching with same value", () => {
-    // render input with initial value
-    const template = `<input type="checkbox" t-att-checked="v"/>`;
-    const bnode1 = renderToBdom(template, { v: true });
-    const fixture = makeTestFixture();
-    mount(bnode1, fixture);
-    const input = fixture.querySelector("input")!;
-    expect(input.checked).toBe(true);
-
-    // change checked manually in input, to simulate user input
-    input.checked = false;
-    expect(input.checked).toBe(false);
-
-    const bnode2 = renderToBdom(template, { v: true });
-    patch(bnode1, bnode2);
-    expect(input.checked).toBe(true);
-  });
-
-  test("input of type checkbox with t-att-indeterminate", () => {
-    const template = `<input type="checkbox" t-att-indeterminate="v"/>`;
-    const bnode1 = renderToBdom(template, { v: true });
-    const fixture = makeTestFixture();
-    mount(bnode1, fixture);
-    const input = fixture.querySelector("input")!;
-    expect(input.indeterminate).toBe(true);
-  });
-
-  test("textarea with t-att-value", () => {
-    // render textarea with initial value
-    const template = `<textarea t-att-value="v"/>`;
-    const bnode1 = renderToBdom(template, { v: "zucchini" });
-    const fixture = makeTestFixture();
-    mount(bnode1, fixture);
-    const elm = fixture.querySelector("textarea")!;
-    expect(elm.value).toBe("zucchini");
-
-    // change value manually in textarea, to simulate user textarea
-    elm.value = "tomato";
-    expect(elm.value).toBe("tomato");
-
-    // rerender with a different value, and patch actual dom, to check that
-    // textarea value was properly reset by owl
-    const bnode2 = renderToBdom(template, { v: "potato" });
-    patch(bnode1, bnode2);
-    expect(elm.value).toBe("potato");
-  });
-
-  test("select with t-att-value", () => {
-    const template = `
-      <select t-att-value="value">
-        <option value="potato">Potato</option>
-        <option value="tomato">Tomato</option>
-        <option value="onion">Onion</option>
-      </select>`;
-    const bnode1 = renderToBdom(template, { value: "tomato" });
-    const fixture = makeTestFixture();
-    mount(bnode1, fixture);
-    const elm = fixture.querySelector("select")!;
-    expect(elm.value).toBe("tomato");
-
-    elm.value = "potato";
-    expect(elm.value).toBe("potato");
-
-    // rerender with a different value, and patch actual dom, to check that
-    // select value was properly reset by owl
-    const bnode2 = renderToBdom(template, { value: "onion" });
-    patch(bnode1, bnode2);
-    expect(elm.value).toBe("onion");
-  });
-});

tests/compiler/properties.test.ts

@@ -0,0 +1,213 @@
+import { mount, patch } from "../../src/runtime/blockdom";
+import { makeTestFixture, renderToBdom, renderToString, snapshotEverything } from "../helpers";
+
+snapshotEverything();
+test("changing an attribute with t-att-", () => {
+  // render input with initial value
+  const template = `<div t-att-value="v"/>`;
+  const bnode1 = renderToBdom(template, { v: "zucchini" });
+  const fixture = makeTestFixture();
+  mount(bnode1, fixture);
+
+  expect(fixture.innerHTML).toBe('<div value="zucchini"></div>');
+
+  const bnode2 = renderToBdom(template, { v: "potato" });
+  patch(bnode1, bnode2);
+  expect(fixture.innerHTML).toBe('<div value="potato"></div>');
+
+  const bnode3 = renderToBdom(template, { v: "" });
+  patch(bnode1, bnode3);
+  // not sure about this. maybe we want to remove the attribute?
+  expect(fixture.innerHTML).toBe('<div value=""></div>');
+});
+
+test("dynamic input value: falsy values", () => {
+  // 0 doesn't fall back to empty string
+  expect(renderToBdom(`<input t-att-value="0"/>`)).toEqual({ data: [new String("0")] });
+  expect(renderToBdom(`<input t-att-value="false"/>`)).toEqual({ data: [new String("")] });
+  expect(renderToBdom(`<input t-att-value="undefined"/>`)).toEqual({ data: [new String("")] });
+  expect(renderToBdom(`<input t-att-value="''"/>`)).toEqual({ data: [new String("")] });
+});
+
+test("updating property with falsy value", async () => {
+  // render input with initial value
+  const template = `<input t-att-value="v"></input>`;
+  const bnode1 = renderToBdom(template, { v: false });
+  const fixture = makeTestFixture();
+  mount(bnode1, fixture);
+
+  const input = fixture.querySelector("input")!;
+  expect(input.value).toBe("");
+
+  patch(bnode1, renderToBdom(template, { v: "owl" }));
+  expect(input.value).toBe("owl");
+
+  patch(bnode1, renderToBdom(template, { v: false }));
+  expect(input.value).toBe("");
+
+  patch(bnode1, renderToBdom(template, { v: "owl" }));
+  expect(input.value).toBe("owl");
+
+  patch(bnode1, renderToBdom(template, { v: undefined }));
+  expect(input.value).toBe("");
+
+  patch(bnode1, renderToBdom(template, { v: "owl" }));
+  expect(input.value).toBe("owl");
+
+  patch(bnode1, renderToBdom(template, { v: null }));
+  expect(input.value).toBe("");
+});
+
+test("input type= checkbox, with t-att-checked", () => {
+  const template = `<input type="checkbox" t-att-checked="flag"/>`;
+  const result = renderToString(template, { flag: true });
+  expect(result).toBe(`<input type="checkbox">`);
+});
+
+test("various boolean html attributes", () => {
+  // will cause the template to be snapshotted
+  renderToString(`
+      <div>
+        <input type="checkbox" checked="checked"/>
+        <input checked="checked"/>
+        <div checked="checked"/>
+        <div selected="selected"/>
+        <option selected="selected" other="1"/>
+        <input readonly="readonly"/>
+        <button disabled="disabled"/>
+      </div>
+      `);
+});
+
+test("input with t-att-value", () => {
+  // render input with initial value
+  const template = `<input  t-att-value="v"/>`;
+  const bnode1 = renderToBdom(template, { v: "zucchini" });
+  const fixture = makeTestFixture();
+  mount(bnode1, fixture);
+  const input = fixture.querySelector("input")!;
+  expect(input.value).toBe("zucchini");
+
+  // change value manually in input, to simulate user input
+  input.value = "tomato";
+  expect(input.value).toBe("tomato");
+
+  // rerender with a different value, and patch actual dom, to check that
+  // input value was properly reset by owl
+  const bnode2 = renderToBdom(template, { v: "potato" });
+  patch(bnode1, bnode2);
+  expect(input.value).toBe("potato");
+});
+
+test("input with t-att-value (patching with same value", () => {
+  // render input with initial value
+  const template = `<input t-att-value="v"/>`;
+  const bnode1 = renderToBdom(template, { v: "zucchini" });
+  const fixture = makeTestFixture();
+  mount(bnode1, fixture);
+  const input = fixture.querySelector("input")!;
+  expect(input.value).toBe("zucchini");
+
+  // change value manually in input, to simulate user input
+  input.value = "tomato";
+  expect(input.value).toBe("tomato");
+
+  const bnode2 = renderToBdom(template, { v: "zucchini" });
+  patch(bnode1, bnode2);
+  expect(input.value).toBe("zucchini");
+});
+
+test("input, type checkbox, with t-att-checked (patching with same value", () => {
+  // render input with initial value
+  const template = `<input type="checkbox" t-att-checked="v"/>`;
+  const bnode1 = renderToBdom(template, { v: true });
+  const fixture = makeTestFixture();
+  mount(bnode1, fixture);
+  const input = fixture.querySelector("input")!;
+  expect(input.checked).toBe(true);
+
+  // change checked manually in input, to simulate user input
+  input.checked = false;
+  expect(input.checked).toBe(false);
+
+  const bnode2 = renderToBdom(template, { v: true });
+  patch(bnode1, bnode2);
+  expect(input.checked).toBe(true);
+});
+
+test("input of type checkbox with t-att-indeterminate", () => {
+  const template = `<input type="checkbox" t-att-indeterminate="v"/>`;
+  const bnode1 = renderToBdom(template, { v: true });
+  const fixture = makeTestFixture();
+  mount(bnode1, fixture);
+  const input = fixture.querySelector("input")!;
+  expect(input.indeterminate).toBe(true);
+});
+
+test("textarea with t-att-value", () => {
+  // render textarea with initial value
+  const template = `<textarea t-att-value="v"/>`;
+  const bnode1 = renderToBdom(template, { v: "zucchini" });
+  const fixture = makeTestFixture();
+  mount(bnode1, fixture);
+  const elm = fixture.querySelector("textarea")!;
+  expect(elm.value).toBe("zucchini");
+
+  // change value manually in textarea, to simulate user textarea
+  elm.value = "tomato";
+  expect(elm.value).toBe("tomato");
+
+  // rerender with a different value, and patch actual dom, to check that
+  // textarea value was properly reset by owl
+  const bnode2 = renderToBdom(template, { v: "potato" });
+  patch(bnode1, bnode2);
+  expect(elm.value).toBe("potato");
+});
+
+test("select with t-att-value", () => {
+  const template = `
+      <select t-att-value="value">
+        <option value="potato">Potato</option>
+        <option value="tomato">Tomato</option>
+        <option value="onion">Onion</option>
+      </select>`;
+  const bnode1 = renderToBdom(template, { value: "tomato" });
+  const fixture = makeTestFixture();
+  mount(bnode1, fixture);
+  const elm = fixture.querySelector("select")!;
+  expect(elm.value).toBe("tomato");
+
+  elm.value = "potato";
+  expect(elm.value).toBe("potato");
+
+  // rerender with a different value, and patch actual dom, to check that
+  // select value was properly reset by owl
+  const bnode2 = renderToBdom(template, { value: "onion" });
+  patch(bnode1, bnode2);
+  expect(elm.value).toBe("onion");
+});
+
+test("readonly and readOnly are both interpreted as the readOnly property", () => {
+  // render input with initial value
+  const staticTemplates = [`<input readonly=""/>`, `<input readOnly=""/>`];
+  for (let template of staticTemplates) {
+    const fixture = makeTestFixture();
+    const bnode1 = renderToBdom(template);
+    mount(bnode1, fixture);
+    const input = fixture.querySelector("input")!;
+    expect(input.readOnly).toBe(true);
+  }
+
+  const dynamicTemplates = [`<input t-att-readonly="val"/>`, `<input t-att-readOnly="val"/>`];
+  for (let template of dynamicTemplates) {
+    const fixture = makeTestFixture();
+    const bnode1 = renderToBdom(template, { val: true });
+    mount(bnode1, fixture);
+    const input = fixture.querySelector("input")!;
+    expect(input.readOnly).toBe(true);
+
+    const bnode2 = renderToBdom(template, { val: false });
+    patch(bnode1, bnode2);
+    expect(input.readOnly).toBe(false);
+  }
+});

tests/components/__snapshots__/slots.test.ts.snap

@@ -282,47 +282,6 @@ exports[`slots can use t-call in default-content of t-slot 3`] = `
 }"
 `;
 
-exports[`slots conditional slot 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  let { capture, markRaw } = helpers;
-  const comp1 = app.createComponent(\`Child\`, true, true, false, true);
-  
-  function slot1(ctx, node, key = \\"\\") {
-    return text(\`blue\`);
-  }
-  
-  function slot2(ctx, node, key = \\"\\") {
-    return text(\`red\`);
-  }
-  
-  return function template(ctx, node, key = \\"\\") {
-    let slots1 = {};
-    if (ctx['state'].flag) {
-      const ctx1 = capture(ctx);
-      slots1['abc'] = {__render: slot1.bind(this), __ctx: ctx1};
-    } else {
-      const ctx2 = capture(ctx);
-      slots1['abc'] = {__render: slot2.bind(this), __ctx: ctx2};
-    }
-    return comp1({slots: markRaw(slots1)}, key + \`__1\`, node, this, null);
-  }
-}"
-`;
-
-exports[`slots conditional slot 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  let { callSlot } = helpers;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return callSlot(ctx, node, key, 'abc', false, {});
-  }
-}"
-`;
-
 exports[`slots content is the default slot (variation) 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -1476,8 +1435,7 @@ exports[`slots simple default slot 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let slots1 = markRaw({'default': {__render: slot1.bind(this), __ctx: ctx}});
-    return comp1({slots: slots1}, key + \`__1\`, node, this, null);
+    return comp1({slots: markRaw({'default': {__render: slot1.bind(this), __ctx: ctx}})}, key + \`__1\`, node, this, null);
   }
 }"
 `;
@@ -1576,8 +1534,7 @@ exports[`slots simple default slot, variation 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let slots1 = markRaw({'default': {__render: slot1.bind(this), __ctx: ctx}});
-    return comp1({slots: slots1}, key + \`__1\`, node, this, null);
+    return comp1({slots: markRaw({'default': {__render: slot1.bind(this), __ctx: ctx}})}, key + \`__1\`, node, this, null);
   }
 }"
 `;
@@ -2884,23 +2841,16 @@ exports[`slots t-set-slot=default has priority over rest of the content 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  let { markRaw, capture } = helpers;
+  let { capture, markRaw } = helpers;
   const comp1 = app.createComponent(\`Child\`, true, true, false, true);
   
   function slot1(ctx, node, key = \\"\\") {
-    const b2 = text(\` some text \`);
-    const ctx2 = capture(ctx);
-    return multi([b2]);
-  }
-  
-  function slot2(ctx, node, key = \\"\\") {
     return text(\`some other text\`);
   }
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let slots1 = markRaw({'default': {__render: slot1.bind(this), __ctx: ctx1}});
-    return comp1({slots: slots1}, key + \`__1\`, node, this, null);
+    return comp1({slots: markRaw({'default': {__render: slot1.bind(this), __ctx: ctx1}})}, key + \`__1\`, node, this, null);
   }
 }"
 `;

tests/components/__snapshots__/t_model.test.ts.snap

@@ -6,15 +6,15 @@ exports[`t-model directive .lazy modifier 1`] = `
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><input block-attribute-0=\\"value\\" block-handler-1=\\"change\\"/><span><block-text-2/></span></div>\`);
+  let block1 = createBlock(\`<div><input block-property-0=\\"value\\" block-handler-1=\\"change\\"/><span><block-text-2/></span></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'text';
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     let txt1 = ctx['state'].text;
-    return block1([attr1, hdlr1, txt1]);
+    return block1([prop1, hdlr1, txt1]);
   }
 }"
 `;
@@ -25,15 +25,15 @@ exports[`t-model directive .number modifier 1`] = `
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
+  let block1 = createBlock(\`<div><input block-property-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'number';
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = toNumber(ev.target.value); }];
     let txt1 = ctx['state'].number;
-    return block1([attr1, hdlr1, txt1]);
+    return block1([prop1, hdlr1, txt1]);
   }
 }"
 `;
@@ -44,15 +44,15 @@ exports[`t-model directive .trim modifier 1`] = `
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
+  let block1 = createBlock(\`<div><input block-property-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'text';
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value.trim(); }];
     let txt1 = ctx['state'].text;
-    return block1([attr1, hdlr1, txt1]);
+    return block1([prop1, hdlr1, txt1]);
   }
 }"
 `;
@@ -63,15 +63,15 @@ exports[`t-model directive basic use, on an input 1`] = `
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
+  let block1 = createBlock(\`<div><input block-property-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'text';
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     let txt1 = ctx['state'].text;
-    return block1([attr1, hdlr1, txt1]);
+    return block1([prop1, hdlr1, txt1]);
   }
 }"
 `;
@@ -82,15 +82,15 @@ exports[`t-model directive basic use, on an input with bracket expression 1`] =
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
+  let block1 = createBlock(\`<div><input block-property-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'text';
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     let txt1 = ctx['state'].text;
-    return block1([attr1, hdlr1, txt1]);
+    return block1([prop1, hdlr1, txt1]);
   }
 }"
 `;
@@ -101,15 +101,15 @@ exports[`t-model directive basic use, on another key in component 1`] = `
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
+  let block1 = createBlock(\`<div><input block-property-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['some'];
     const expr1 = 'text';
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     let txt1 = ctx['some'].text;
-    return block1([attr1, hdlr1, txt1]);
+    return block1([prop1, hdlr1, txt1]);
   }
 }"
 `;
@@ -120,15 +120,15 @@ exports[`t-model directive can also define t-on directive on same event, part 1
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><input block-attribute-0=\\"value\\" block-handler-1=\\"input\\" block-handler-2=\\"input\\"/></div>\`);
+  let block1 = createBlock(\`<div><input block-property-0=\\"value\\" block-handler-1=\\"input\\" block-handler-2=\\"input\\"/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'text';
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     let hdlr2 = [ctx['onInput'], ctx];
-    return block1([attr1, hdlr1, hdlr2]);
+    return block1([prop1, hdlr1, hdlr2]);
   }
 }"
 `;
@@ -139,25 +139,25 @@ exports[`t-model directive can also define t-on directive on same event, part 2
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><input type=\\"radio\\" id=\\"one\\" value=\\"One\\" block-attribute-0=\\"checked\\" block-handler-1=\\"click\\" block-handler-2=\\"click\\"/><input type=\\"radio\\" id=\\"two\\" value=\\"Two\\" block-attribute-3=\\"checked\\" block-handler-4=\\"click\\" block-handler-5=\\"click\\"/><input type=\\"radio\\" id=\\"three\\" value=\\"Three\\" block-attribute-6=\\"checked\\" block-handler-7=\\"click\\" block-handler-8=\\"click\\"/></div>\`);
+  let block1 = createBlock(\`<div><input type=\\"radio\\" id=\\"one\\" value=\\"One\\" block-property-0=\\"checked\\" block-handler-1=\\"click\\" block-handler-2=\\"click\\"/><input type=\\"radio\\" id=\\"two\\" value=\\"Two\\" block-property-3=\\"checked\\" block-handler-4=\\"click\\" block-handler-5=\\"click\\"/><input type=\\"radio\\" id=\\"three\\" value=\\"Three\\" block-property-6=\\"checked\\" block-handler-7=\\"click\\" block-handler-8=\\"click\\"/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'choice';
-    let attr1 = bExpr1[expr1] === 'One';
+    let prop1 = bExpr1[expr1] === 'One';
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     let hdlr2 = [ctx['onClick'], ctx];
     const bExpr2 = ctx['state'];
     const expr2 = 'choice';
-    let attr2 = bExpr2[expr2] === 'Two';
+    let prop2 = bExpr2[expr2] === 'Two';
     let hdlr3 = [(ev) => { bExpr2[expr2] = ev.target.value; }];
     let hdlr4 = [ctx['onClick'], ctx];
     const bExpr3 = ctx['state'];
     const expr3 = 'choice';
-    let attr3 = bExpr3[expr3] === 'Three';
+    let prop3 = bExpr3[expr3] === 'Three';
     let hdlr5 = [(ev) => { bExpr3[expr3] = ev.target.value; }];
     let hdlr6 = [ctx['onClick'], ctx];
-    return block1([attr1, hdlr1, hdlr2, attr2, hdlr3, hdlr4, attr3, hdlr5, hdlr6]);
+    return block1([prop1, hdlr1, hdlr2, prop2, hdlr3, hdlr4, prop3, hdlr5, hdlr6]);
   }
 }"
 `;
@@ -168,7 +168,7 @@ exports[`t-model directive following a scope protecting directive (e.g. t-set) 1
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { isBoundary, withDefault, setContextValue, toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/></div>\`);
+  let block1 = createBlock(\`<div><input block-property-0=\\"value\\" block-handler-1=\\"input\\"/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
@@ -176,9 +176,9 @@ exports[`t-model directive following a scope protecting directive (e.g. t-set) 1
     setContextValue(ctx, \\"admiral\\", 'Bruno');
     const bExpr1 = ctx['state'];
     const expr1 = 'text';
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
-    return block1([attr1, hdlr1]);
+    return block1([prop1, hdlr1]);
   }
 }"
 `;
@@ -190,7 +190,7 @@ exports[`t-model directive in a t-foreach 1`] = `
   let { prepareList, toNumber, withKey } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
-  let block3 = createBlock(\`<input type=\\"checkbox\\" block-attribute-0=\\"checked\\" block-handler-1=\\"input\\"/>\`);
+  let block3 = createBlock(\`<input type=\\"checkbox\\" block-property-0=\\"checked\\" block-handler-1=\\"input\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
@@ -200,9 +200,9 @@ exports[`t-model directive in a t-foreach 1`] = `
       const key1 = ctx['thing'].id;
       const bExpr1 = ctx['thing'];
       const expr1 = 'f';
-      let attr1 = bExpr1[expr1];
+      let prop1 = bExpr1[expr1];
       let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.checked; }];
-      c_block2[i1] = withKey(block3([attr1, hdlr1]), key1);
+      c_block2[i1] = withKey(block3([prop1, hdlr1]), key1);
     }
     const b2 = list(c_block2);
     return block1([], [b2]);
@@ -217,7 +217,7 @@ exports[`t-model directive in a t-foreach, part 2 1`] = `
   let { prepareList, toNumber, withKey } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
-  let block3 = createBlock(\`<input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>\`);
+  let block3 = createBlock(\`<input block-property-0=\\"value\\" block-handler-1=\\"input\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
@@ -228,9 +228,9 @@ exports[`t-model directive in a t-foreach, part 2 1`] = `
       const key1 = ctx['thing_index'];
       const bExpr1 = ctx['state'];
       const expr1 = ctx['thing_index'];
-      let attr1 = bExpr1[expr1];
+      let prop1 = bExpr1[expr1];
       let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
-      c_block2[i1] = withKey(block3([attr1, hdlr1]), key1);
+      c_block2[i1] = withKey(block3([prop1, hdlr1]), key1);
     }
     const b2 = list(c_block2);
     return block1([], [b2]);
@@ -245,7 +245,7 @@ exports[`t-model directive in a t-foreach, part 3 1`] = `
   let { prepareList, toNumber, withKey } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
-  let block3 = createBlock(\`<input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>\`);
+  let block3 = createBlock(\`<input block-property-0=\\"value\\" block-handler-1=\\"input\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
@@ -256,9 +256,9 @@ exports[`t-model directive in a t-foreach, part 3 1`] = `
       const key1 = ctx['name_index'];
       const bExpr1 = ctx['state'].values;
       const expr1 = ctx['name'];
-      let attr1 = bExpr1[expr1];
+      let prop1 = bExpr1[expr1];
       let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
-      c_block2[i1] = withKey(block3([attr1, hdlr1]), key1);
+      c_block2[i1] = withKey(block3([prop1, hdlr1]), key1);
     }
     const b2 = list(c_block2);
     return block1([], [b2]);
@@ -272,15 +272,15 @@ exports[`t-model directive on a select 1`] = `
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><select block-attribute-0=\\"value\\" block-handler-1=\\"change\\"><option value=\\"\\">Please select one</option><option value=\\"red\\">Red</option><option value=\\"blue\\">Blue</option></select><span>Choice: <block-text-2/></span></div>\`);
+  let block1 = createBlock(\`<div><select block-property-0=\\"value\\" block-handler-1=\\"change\\"><option value=\\"\\">Please select one</option><option value=\\"red\\">Red</option><option value=\\"blue\\">Blue</option></select><span>Choice: <block-text-2/></span></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'color';
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     let txt1 = ctx['state'].color;
-    return block1([attr1, hdlr1, txt1]);
+    return block1([prop1, hdlr1, txt1]);
   }
 }"
 `;
@@ -291,14 +291,14 @@ exports[`t-model directive on a select, initial state 1`] = `
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><select block-attribute-0=\\"value\\" block-handler-1=\\"change\\"><option value=\\"\\">Please select one</option><option value=\\"red\\">Red</option><option value=\\"blue\\">Blue</option></select></div>\`);
+  let block1 = createBlock(\`<div><select block-property-0=\\"value\\" block-handler-1=\\"change\\"><option value=\\"\\">Please select one</option><option value=\\"red\\">Red</option><option value=\\"blue\\">Blue</option></select></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'color';
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
-    return block1([attr1, hdlr1]);
+    return block1([prop1, hdlr1]);
   }
 }"
 `;
@@ -309,15 +309,15 @@ exports[`t-model directive on a sub state key 1`] = `
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
+  let block1 = createBlock(\`<div><input block-property-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'].something;
     const expr1 = 'text';
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     let txt1 = ctx['state'].something.text;
-    return block1([attr1, hdlr1, txt1]);
+    return block1([prop1, hdlr1, txt1]);
   }
 }"
 `;
@@ -328,19 +328,19 @@ exports[`t-model directive on an input type=radio 1`] = `
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><input type=\\"radio\\" id=\\"one\\" value=\\"One\\" block-attribute-0=\\"checked\\" block-handler-1=\\"click\\"/><input type=\\"radio\\" id=\\"two\\" value=\\"Two\\" block-attribute-2=\\"checked\\" block-handler-3=\\"click\\"/><span>Choice: <block-text-4/></span></div>\`);
+  let block1 = createBlock(\`<div><input type=\\"radio\\" id=\\"one\\" value=\\"One\\" block-property-0=\\"checked\\" block-handler-1=\\"click\\"/><input type=\\"radio\\" id=\\"two\\" value=\\"Two\\" block-property-2=\\"checked\\" block-handler-3=\\"click\\"/><span>Choice: <block-text-4/></span></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'choice';
-    let attr1 = bExpr1[expr1] === 'One';
+    let prop1 = bExpr1[expr1] === 'One';
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     const bExpr2 = ctx['state'];
     const expr2 = 'choice';
-    let attr2 = bExpr2[expr2] === 'Two';
+    let prop2 = bExpr2[expr2] === 'Two';
     let hdlr2 = [(ev) => { bExpr2[expr2] = ev.target.value; }];
     let txt1 = ctx['state'].choice;
-    return block1([attr1, hdlr1, attr2, hdlr2, txt1]);
+    return block1([prop1, hdlr1, prop2, hdlr2, txt1]);
   }
 }"
 `;
@@ -351,18 +351,18 @@ exports[`t-model directive on an input type=radio, with initial value 1`] = `
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><input type=\\"radio\\" id=\\"one\\" value=\\"One\\" block-attribute-0=\\"checked\\" block-handler-1=\\"click\\"/><input type=\\"radio\\" id=\\"two\\" value=\\"Two\\" block-attribute-2=\\"checked\\" block-handler-3=\\"click\\"/></div>\`);
+  let block1 = createBlock(\`<div><input type=\\"radio\\" id=\\"one\\" value=\\"One\\" block-property-0=\\"checked\\" block-handler-1=\\"click\\"/><input type=\\"radio\\" id=\\"two\\" value=\\"Two\\" block-property-2=\\"checked\\" block-handler-3=\\"click\\"/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'choice';
-    let attr1 = bExpr1[expr1] === 'One';
+    let prop1 = bExpr1[expr1] === 'One';
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     const bExpr2 = ctx['state'];
     const expr2 = 'choice';
-    let attr2 = bExpr2[expr2] === 'Two';
+    let prop2 = bExpr2[expr2] === 'Two';
     let hdlr2 = [(ev) => { bExpr2[expr2] = ev.target.value; }];
-    return block1([attr1, hdlr1, attr2, hdlr2]);
+    return block1([prop1, hdlr1, prop2, hdlr2]);
   }
 }"
 `;
@@ -373,20 +373,20 @@ exports[`t-model directive on an input, type=checkbox 1`] = `
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><input type=\\"checkbox\\" block-attribute-0=\\"checked\\" block-handler-1=\\"input\\"/><span><block-child-0/><block-child-1/></span></div>\`);
+  let block1 = createBlock(\`<div><input type=\\"checkbox\\" block-property-0=\\"checked\\" block-handler-1=\\"input\\"/><span><block-child-0/><block-child-1/></span></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     let b2,b3;
     const bExpr1 = ctx['state'];
     const expr1 = 'flag';
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.checked; }];
     if (ctx['state'].flag) {
       b2 = text(\`yes\`);
     } else {
       b3 = text(\`no\`);
     }
-    return block1([attr1, hdlr1], [b2, b3]);
+    return block1([prop1, hdlr1], [b2, b3]);
   }
 }"
 `;
@@ -397,15 +397,15 @@ exports[`t-model directive on an textarea 1`] = `
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><textarea block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
+  let block1 = createBlock(\`<div><textarea block-property-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'text';
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     let txt1 = ctx['state'].text;
-    return block1([attr1, hdlr1, txt1]);
+    return block1([prop1, hdlr1, txt1]);
   }
 }"
 `;
@@ -416,15 +416,15 @@ exports[`t-model directive t-model is applied before t-on-input 1`] = `
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><input block-attribute-0=\\"value\\" block-handler-1=\\"input\\" block-handler-2=\\"input\\"/></div>\`);
+  let block1 = createBlock(\`<div><input block-property-0=\\"value\\" block-handler-1=\\"input\\" block-handler-2=\\"input\\"/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'text';
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     let hdlr2 = [ctx['onInput'], ctx];
-    return block1([attr1, hdlr1, hdlr2]);
+    return block1([prop1, hdlr1, hdlr2]);
   }
 }"
 `;
@@ -435,14 +435,14 @@ exports[`t-model directive t-model on an input with an undefined value 1`] = `
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>\`);
+  let block1 = createBlock(\`<input block-property-0=\\"value\\" block-handler-1=\\"input\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'text';
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
-    return block1([attr1, hdlr1]);
+    return block1([prop1, hdlr1]);
   }
 }"
 `;
@@ -453,17 +453,17 @@ exports[`t-model directive t-model on select with static options 1`] = `
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><select block-attribute-0=\\"value\\" block-handler-1=\\"change\\"><option value=\\"a\\"><block-text-2/></option><option value=\\"b\\"><block-text-3/></option><option value=\\"c\\"><block-text-4/></option></select></div>\`);
+  let block1 = createBlock(\`<div><select block-property-0=\\"value\\" block-handler-1=\\"change\\"><option value=\\"a\\"><block-text-2/></option><option value=\\"b\\"><block-text-3/></option><option value=\\"c\\"><block-text-4/></option></select></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'model';
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     let txt1 = 'a';
     let txt2 = 'b';
     let txt3 = 'c';
-    return block1([attr1, hdlr1, txt1, txt2, txt3]);
+    return block1([prop1, hdlr1, txt1, txt2, txt3]);
   }
 }"
 `;
@@ -576,7 +576,7 @@ exports[`t-model directive t-model with radio button group in t-foreach 1`] = `
   let { prepareList, toNumber, withKey } = helpers;
   
   let block1 = createBlock(\`<div id=\\"get_data\\" block-handler-0=\\"click\\"><block-child-0/></div>\`);
-  let block3 = createBlock(\`<input type=\\"radio\\" name=\\"radio_group\\" block-attribute-0=\\"value\\" block-attribute-1=\\"id\\" block-attribute-2=\\"checked\\" block-handler-3=\\"click\\"/>\`);
+  let block3 = createBlock(\`<input type=\\"radio\\" name=\\"radio_group\\" block-property-0=\\"value\\" block-attribute-1=\\"id\\" block-property-2=\\"checked\\" block-handler-3=\\"click\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
     let hdlr1 = [ctx['getData'], ctx];
@@ -585,13 +585,13 @@ exports[`t-model directive t-model with radio button group in t-foreach 1`] = `
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`opt\`] = v_block2[i1];
       const key1 = ctx['opt'];
-      let attr1 = new String((ctx['opt']) || \\"\\");
-      let attr2 = ctx['opt'];
+      let prop1 = new String((ctx['opt']) === 0 ? 0 : ((ctx['opt']) || \\"\\"));
+      let attr1 = ctx['opt'];
       const bExpr1 = ctx['state'];
       const expr1 = 'group';
-      let attr3 = bExpr1[expr1] === ctx['opt'];
+      let prop2 = bExpr1[expr1] === ctx['opt'];
       let hdlr2 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
-      c_block2[i1] = withKey(block3([attr1, attr2, attr3, hdlr2]), key1);
+      c_block2[i1] = withKey(block3([prop1, attr1, prop2, hdlr2]), key1);
     }
     const b2 = list(c_block2);
     return block1([hdlr1], [b2]);
@@ -606,24 +606,24 @@ exports[`t-model directive two inputs in a div alternating with a t-if 1`] = `
   let { toNumber } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
-  let block2 = createBlock(\`<input class=\\"a\\" block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>\`);
-  let block3 = createBlock(\`<input class=\\"b\\" block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/>\`);
+  let block2 = createBlock(\`<input class=\\"a\\" block-property-0=\\"value\\" block-handler-1=\\"input\\"/>\`);
+  let block3 = createBlock(\`<input class=\\"b\\" block-property-0=\\"value\\" block-handler-1=\\"input\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
     let b2,b3;
     if (ctx['state'].flag) {
       const bExpr1 = ctx['state'];
       const expr1 = 'text1';
-      let attr1 = bExpr1[expr1];
+      let prop1 = bExpr1[expr1];
       let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
-      b2 = block2([attr1, hdlr1]);
+      b2 = block2([prop1, hdlr1]);
     }
     if (!ctx['state'].flag) {
       const bExpr2 = ctx['state'];
       const expr2 = 'text2';
-      let attr2 = bExpr2[expr2];
+      let prop2 = bExpr2[expr2];
       let hdlr2 = [(ev) => { bExpr2[expr2] = ev.target.value; }];
-      b3 = block3([attr2, hdlr2]);
+      b3 = block3([prop2, hdlr2]);
     }
     return block1([], [b2, b3]);
   }
@@ -636,15 +636,15 @@ exports[`t-model directive with expression having a changing key 1`] = `
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   let { toNumber } = helpers;
   
-  let block1 = createBlock(\`<div><input block-attribute-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
+  let block1 = createBlock(\`<div><input block-property-0=\\"value\\" block-handler-1=\\"input\\"/><span><block-text-2/></span></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'].something;
     const expr1 = ctx['text'].key;
-    let attr1 = bExpr1[expr1];
+    let prop1 = bExpr1[expr1];
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     let txt1 = ctx['state'].something[ctx['text'].key];
-    return block1([attr1, hdlr1, txt1]);
+    return block1([prop1, hdlr1, txt1]);
   }
 }"
 `;

tests/components/slots.test.ts

@@ -62,7 +62,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("some other text");
   });
 
-  test.skip("simple slot with slot scope", async () => {
+  test("simple slot with slot scope", async () => {
     let child: any;
     class Child extends Component {
       static template = xml`<span><t t-slot="slotName" bool="state.bool"/></span>`;
@@ -91,7 +91,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<span>other text</span>");
   });
 
-  test.skip("slot with slot scope and t-props", async () => {
+  test("slot with slot scope and t-props", async () => {
     class Child extends Component {
       static template = xml`
         <t t-slot="slotName" t-props="info"/>`;
@@ -113,7 +113,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<p>1</p><p>2</p>");
   });
 
-  test.skip("simple dynamic slot with slot scope", async () => {
+  test("simple dynamic slot with slot scope", async () => {
     let child: any;
     class Child extends Component {
       static template = xml`<span><t t-slot="{{ 'slotName' }}" bool="state.bool"/></span>`;
@@ -142,7 +142,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<span>other text</span>");
   });
 
-  test.skip("simple named and empty slot", async () => {
+  test("simple named and empty slot", async () => {
     class Child extends Component {
       static template = xml`<span><t t-slot="default" /><t t-slot="myEmptySlot"/></span>`;
 
@@ -160,7 +160,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<span>some text</span>");
   });
 
-  test.skip("simple named and empty slot -- 2", async () => {
+  test("simple named and empty slot -- 2", async () => {
     class Child extends Component {
       static template = xml`<span><t t-slot="myEmptySlot">default empty</t></span>`;
 
@@ -179,7 +179,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<span>default empty</span>");
   });
 
-  test.skip("default slot with slot scope: shorthand syntax", async () => {
+  test("default slot with slot scope: shorthand syntax", async () => {
     let child: any;
     class Child extends Component {
       static template = xml`<span><t t-slot="default" bool="state.bool"/></span>`;
@@ -206,7 +206,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<span>other text</span>");
   });
 
-  test.skip("simple default slot with params", async () => {
+  test("simple default slot with params", async () => {
     class Child extends Component {
       static template = xml`<span><t t-slot="default" bool="state.bool"/></span>`;
       state = useState({ bool: true });
@@ -230,7 +230,7 @@ describe("slots", () => {
     expect(mockConsoleWarn).toBeCalledTimes(1);
   });
 
-  test.skip("simple default slot with params and bound function", async () => {
+  test("simple default slot with params and bound function", async () => {
     class Child extends Component {
       static template = xml`<t t-slot="default" fn.bind="getValue"/>`;
       state = useState({ value: 123 });
@@ -249,7 +249,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("123");
   });
 
-  test.skip("default slot with params with - in it", async () => {
+  test("default slot with params with - in it", async () => {
     class Child extends Component {
       static template = xml`<t t-slot="default" some-value="state.value"/>`;
       state = useState({ value: 123 });
@@ -265,7 +265,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("123");
   });
 
-  test.skip("fun: two calls to the same slot", async () => {
+  test("fun: two calls to the same slot", async () => {
     class Child extends Component {
       static template = xml`<t t-slot="default"/><t t-slot="default"/>`;
     }
@@ -279,7 +279,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("some textsome text");
   });
 
-  test.skip("slot content is bound to caller", async () => {
+  test("slot content is bound to caller", async () => {
     class Child extends Component {
       static template = xml`<span><t t-slot="default"/></span>`;
     }
@@ -299,7 +299,7 @@ describe("slots", () => {
     expect(parent.state.value).toBe(1);
   });
 
-  test.skip("slot content is bound to caller (variation)", async () => {
+  test("slot content is bound to caller (variation)", async () => {
     class Child extends Component {
       static template = xml`<span><t t-slot="default"/></span>`;
     }
@@ -326,7 +326,7 @@ describe("slots", () => {
     expect(parent.state.value).toBe(1);
   });
 
-  test.skip("can define and call slots", async () => {
+  test("can define and call slots", async () => {
     class Dialog extends Component {
       static template = xml`
         <div>
@@ -352,7 +352,7 @@ describe("slots", () => {
     );
   });
 
-  test.skip("can define and call slots with params", async () => {
+  test("can define and call slots with params", async () => {
     class Dialog extends Component {
       static template = xml`
         <div>
@@ -381,7 +381,7 @@ describe("slots", () => {
     );
   });
 
-  test.skip("can define and call slots with bound params", async () => {
+  test("can define and call slots with bound params", async () => {
     class Child extends Component {
       static template = xml`
         <t t-slot="abc"/>
@@ -405,7 +405,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("abc444");
   });
 
-  test.skip("no named slot content => just no children", async () => {
+  test("no named slot content => just no children", async () => {
     class Dialog extends Component {
       static template = xml`<span><t t-slot="header"/></span>`;
     }
@@ -418,7 +418,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<span></span>");
   });
 
-  test.skip("named slots can define a default content", async () => {
+  test("named slots can define a default content", async () => {
     class Dialog extends Component {
       static template = xml`
             <span>
@@ -434,7 +434,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><span>default content</span></div>");
   });
 
-  test.skip("can define a default content", async () => {
+  test("can define a default content", async () => {
     class Dialog extends Component {
       static template = xml`
           <span>
@@ -450,7 +450,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><span>default content</span></div>");
   });
 
-  test.skip("default content is not rendered if slot is provided", async () => {
+  test("default content is not rendered if slot is provided", async () => {
     class Dialog extends Component {
       static template = xml`
             <span>
@@ -466,7 +466,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><span>hey</span></div>");
   });
 
-  test.skip("default content is not rendered if named slot is provided", async () => {
+  test("default content is not rendered if named slot is provided", async () => {
     class Dialog extends Component {
       static template = xml`
             <span>
@@ -482,7 +482,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><span>hey</span></div>");
   });
 
-  test.skip("slots are properly bound to correct component", async () => {
+  test("slots are properly bound to correct component", async () => {
     let child: any = null;
     class Child extends Component {
       // t-set t-value in template is to force compiler to protect the scope
@@ -518,7 +518,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<button>2</button>");
   });
 
-  test.skip("slots are rendered with proper context", async () => {
+  test("slots are rendered with proper context", async () => {
     class Dialog extends Component {
       static template = xml`<span><t t-slot="footer"/></span>`;
     }
@@ -554,7 +554,7 @@ describe("slots", () => {
     );
   });
 
-  test.skip("slots are rendered with proper context, part 2", async () => {
+  test("slots are rendered with proper context, part 2", async () => {
     class Link extends Component {
       static template = xml`
             <a t-att-href="props.to">
@@ -593,7 +593,7 @@ describe("slots", () => {
     );
   });
 
-  test.skip("slots are rendered with proper context, part 3", async () => {
+  test("slots are rendered with proper context, part 3", async () => {
     class Link extends Component {
       static template = xml`
             <a t-att-href="props.to">
@@ -632,7 +632,7 @@ describe("slots", () => {
     );
   });
 
-  test.skip("slots are rendered with proper context, part 4", async () => {
+  test("slots are rendered with proper context, part 4", async () => {
     class Link extends Component {
       static template = xml`
             <a t-att-href="props.to">
@@ -660,7 +660,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe('<div><a href="/user/1">User David</a></div>');
   });
 
-  test.skip("content is the default slot", async () => {
+  test("content is the default slot", async () => {
     class Dialog extends Component {
       static template = xml`<div><t t-slot="default"/></div>`;
     }
@@ -678,7 +678,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><div><span>sts rocks</span></div></div>");
   });
 
-  test.skip("content is the default slot (variation)", async () => {
+  test("content is the default slot (variation)", async () => {
     class Dialog extends Component {
       static template = xml`<t t-slot="default"/>`;
     }
@@ -694,7 +694,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<span>sts rocks</span>");
   });
 
-  test.skip("default slot work with text nodes", async () => {
+  test("default slot work with text nodes", async () => {
     class Dialog extends Component {
       static template = xml`<div><t t-slot="default"/></div>`;
     }
@@ -710,7 +710,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><div>sts rocks</div></div>");
   });
 
-  test.skip("default slot work with text nodes (variation)", async () => {
+  test("default slot work with text nodes (variation)", async () => {
     class Dialog extends Component {
       static template = xml`<t t-slot="default"/>`;
     }
@@ -723,7 +723,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("sts rocks");
   });
 
-  test.skip("multiple roots are allowed in a named slot", async () => {
+  test("multiple roots are allowed in a named slot", async () => {
     class Dialog extends Component {
       static template = xml`<div><t t-slot="content"/></div>`;
     }
@@ -744,7 +744,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><div><span>sts</span><span>rocks</span></div></div>");
   });
 
-  test.skip("multiple roots are allowed in a default slot", async () => {
+  test("multiple roots are allowed in a default slot", async () => {
     class Dialog extends Component {
       static template = xml`<div><t t-slot="default"/></div>`;
     }
@@ -763,7 +763,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><div><span>sts</span><span>rocks</span></div></div>");
   });
 
-  test.skip("missing slots are ignored", async () => {
+  test("missing slots are ignored", async () => {
     class Dialog extends Component {
       static template = xml`
           <span>
@@ -782,7 +782,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><span><span>some content</span></span></div>");
   });
 
-  test.skip("t-debug on a t-set-slot (defining a slot)", async () => {
+  test("t-debug on a t-set-slot (defining a slot)", async () => {
     const consoleLog = console.log;
     console.log = jest.fn();
 
@@ -802,7 +802,7 @@ describe("slots", () => {
     console.log = consoleLog;
   });
 
-  test.skip("slot preserves properly parented relationship", async () => {
+  test("slot preserves properly parented relationship", async () => {
     class Child extends Component {
       static template = xml`<t t-slot="default"/>`;
     }
@@ -832,7 +832,7 @@ describe("slots", () => {
     expect(childrenChildren[0]).toBeInstanceOf(GrandChild);
   });
 
-  test.skip("slot preserves properly parented relationship, even through t-call", async () => {
+  test("slot preserves properly parented relationship, even through t-call", async () => {
     class Child extends Component {
       static template = xml`<t t-slot="default"/>`;
     }
@@ -870,7 +870,7 @@ describe("slots", () => {
     expect(childrenChildren[0]).toBeInstanceOf(GrandChild);
   });
 
-  test.skip("t-slot scope context", async () => {
+  test("t-slot scope context", async () => {
     expect.assertions(4);
 
     class Wrapper extends Component {
@@ -916,7 +916,7 @@ describe("slots", () => {
     await nextTick();
   });
 
-  test.skip("t-slot in recursive templates", async () => {
+  test("t-slot in recursive templates", async () => {
     class Wrapper extends Component {
       static template = xml`
           <wrapper>
@@ -979,7 +979,7 @@ describe("slots", () => {
     );
   });
 
-  test.skip("t-slot within dynamic t-call", async () => {
+  test("t-slot within dynamic t-call", async () => {
     class Child extends Component {
       static template = xml`<div class="child"/>`;
     }
@@ -1021,7 +1021,7 @@ describe("slots", () => {
     );
   });
 
-  test.skip("slots in t-foreach in t-foreach", async () => {
+  test("slots in t-foreach in t-foreach", async () => {
     class Child extends Component {
       static template = xml`
         <div><t t-slot="default" /></div>
@@ -1084,7 +1084,7 @@ describe("slots", () => {
     );
   });
 
-  test.skip("default slot next to named slot, with default content", async () => {
+  test("default slot next to named slot, with default content", async () => {
     class Dialog extends Component {
       // We're using 2 slots here: a "default" one and a "footer",
       // both having default children nodes.
@@ -1125,7 +1125,7 @@ describe("slots", () => {
     );
   });
 
-  test.skip("dynamic t-slot call", async () => {
+  test("dynamic t-slot call", async () => {
     class Toggler extends Component {
       static template = xml`<button t-on-click="toggle"><t t-slot="{{current.slot}}"/></button>`;
       current = useState({ slot: "slot1" });
@@ -1156,7 +1156,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><button><p>slot1</p><span>content</span></button></div>");
   });
 
-  test.skip("dynamic t-slot call with default", async () => {
+  test("dynamic t-slot call with default", async () => {
     class Toggler extends Component {
       static template = xml`
         <button t-on-click="toggle">
@@ -1188,7 +1188,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><button><h1>slot2</h1></button></div>");
   });
 
-  test.skip("slot are properly rendered if inner props are changed", async () => {
+  test("slot are properly rendered if inner props are changed", async () => {
     class SomeComponent extends Component {
       static template = xml`
         <div>
@@ -1222,7 +1222,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><button>Inc[5]</button><div><div> SC:5</div></div></div>");
   });
 
-  test.skip("slots and wrapper components", async () => {
+  test("slots and wrapper components", async () => {
     class Link extends Component {
       static template = xml`
           <a href="abc">
@@ -1240,7 +1240,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe(`<a href="abc">hey</a>`);
   });
 
-  test.skip("template can just return a slot", async () => {
+  test("template can just return a slot", async () => {
     class Child extends Component {
       static template = xml`<span><t t-esc="props.value"/></span>`;
     }
@@ -1265,7 +1265,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><span>5</span></div>");
   });
 
-  test.skip("multiple slots containing components", async () => {
+  test("multiple slots containing components", async () => {
     class C extends Component {
       static template = xml`<span><t t-esc="props.val"/></span>`;
     }
@@ -1286,7 +1286,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe(`<div><span>1</span><span>2</span></div>`);
   });
 
-  test.skip("slots in t-foreach and re-rendering", async () => {
+  test("slots in t-foreach and re-rendering", async () => {
     class Child extends Component {
       static template = xml`<span><t t-esc="state.val"/><t t-slot="default"/></span>`;
       state = useState({ val: "A" });
@@ -1312,7 +1312,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><span>B0</span><span>B1</span></div>");
   });
 
-  test.skip("slots in t-foreach with t-set and re-rendering", async () => {
+  test("slots in t-foreach with t-set and re-rendering", async () => {
     class Child extends Component {
       static template = xml`
           <span>
@@ -1344,7 +1344,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><span>B0</span><span>B1</span></div>");
   });
 
-  test.skip("nested slots in same template", async () => {
+  test("nested slots in same template", async () => {
     let child: any = null;
     let child2: any = null;
     let child3: any = null;
@@ -1398,7 +1398,7 @@ describe("slots", () => {
     expect(children(parent)).toEqual([child]);
   });
 
-  test.skip("t-slot nested within another slot", async () => {
+  test("t-slot nested within another slot", async () => {
     let portal: any = null;
     let modal: any = null;
     let child3: any = null;
@@ -1451,7 +1451,7 @@ describe("slots", () => {
     expect(children(modal)[0]).toBe(portal);
   });
 
-  test.skip("slots in slots, with vars", async () => {
+  test("slots in slots, with vars", async () => {
     class B extends Component {
       static template = xml`<span><t t-slot="default"/></span>`;
     }
@@ -1480,7 +1480,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><div><span><p>heyaaron</p></span></div></div>");
   });
 
-  test.skip("t-set t-value in a slot", async () => {
+  test("t-set t-value in a slot", async () => {
     class Dialog extends Component {
       static template = xml`
           <span>
@@ -1502,7 +1502,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><span>dash</span></div>");
   });
 
-  test.skip("slot and t-esc", async () => {
+  test("slot and t-esc", async () => {
     class Dialog extends Component {
       static template = xml`<span><t t-slot="default"/></span>`;
     }
@@ -1515,7 +1515,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><span>toph</span></div>");
   });
 
-  test.skip("slot and t-call", async () => {
+  test("slot and t-call", async () => {
     let sokka = xml`<p>sokka</p>`;
     class Dialog extends Component {
       static template = xml`<span><t t-slot="default"/></span>`;
@@ -1529,7 +1529,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><span><p>sokka</p></span></div>");
   });
 
-  test.skip("slot and (inline) t-call", async () => {
+  test("slot and (inline) t-call", async () => {
     let sokka = xml`<p>sokka</p>`;
     class Dialog extends Component {
       static template = xml`<span><t t-slot="default"/></span>`;
@@ -1543,7 +1543,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><span><p>sokka</p></span></div>");
   });
 
-  test.skip("nested slots: evaluation context and parented relationship", async () => {
+  test("nested slots: evaluation context and parented relationship", async () => {
     let slot: any = null;
     let grandChild: any = null;
 
@@ -1578,7 +1578,7 @@ describe("slots", () => {
     expect(children(grandChild)).toEqual([slot]);
   });
 
-  test.skip("named slot inside slot", async () => {
+  test("named slot inside slot", async () => {
     class Child extends Component {
       static template = xml`
         <div>
@@ -1608,7 +1608,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><div><p>Ablip</p><div><p>Bblip</p></div></div></div>");
   });
 
-  test.skip("named slots inside slot, again", async () => {
+  test("named slots inside slot, again", async () => {
     class Child extends Component {
       static template = xml`
         <child>
@@ -1641,7 +1641,7 @@ describe("slots", () => {
     );
   });
 
-  test.skip("named slot inside slot, part 3", async () => {
+  test("named slot inside slot, part 3", async () => {
     class Child extends Component {
       static template = xml`
         <div>
@@ -1673,7 +1673,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div><div><p>Ablip</p><div><p>Bblip</p></div></div></div>");
   });
 
-  test.skip("can render only empty slot", async () => {
+  test("can render only empty slot", async () => {
     class Parent extends Component {
       static template = xml`<t t-slot="default"/>`;
     }
@@ -1688,7 +1688,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toEqual("");
   });
 
-  test.skip("can render node with t-ref and Component in same slot", async () => {
+  test("can render node with t-ref and Component in same slot", async () => {
     class Child extends Component {
       static template = xml`<t t-slot="default"/>`;
     }
@@ -1706,7 +1706,7 @@ describe("slots", () => {
     expect(error).toBeNull();
   });
 
-  test.skip("can use t-call in default-content of t-slot", async () => {
+  test("can use t-call in default-content of t-slot", async () => {
     const template = xml``;
     class Child extends Component {
       static template = xml`<t t-slot="default"><t t-call="${template}"/></t>`;
@@ -1719,7 +1719,7 @@ describe("slots", () => {
     await mount(Parent, fixture);
   });
 
-  test.skip("can use component in default-content of t-slot", async () => {
+  test("can use component in default-content of t-slot", async () => {
     class GrandChild extends Component {
       static template = xml``;
     }
@@ -1735,7 +1735,7 @@ describe("slots", () => {
     await mount(Parent, fixture);
   });
 
-  test.skip("slot content has different key from other content -- static slot", async () => {
+  test("slot content has different key from other content -- static slot", async () => {
     class Child extends Component {
       static template = xml`<div t-esc="props.parent" />`;
     }
@@ -1757,7 +1757,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div>SlotDisplay</div><div>Parent</div>");
   });
 
-  test.skip("slot content has different key from other content -- dynamic slot", async () => {
+  test("slot content has different key from other content -- dynamic slot", async () => {
     class Child extends Component {
       static template = xml`<div t-esc="props.parent" />`;
     }
@@ -1780,7 +1780,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<div>SlotDisplay</div><div>Parent</div>");
   });
 
-  test.skip("mix of slots, t-call, t-call with body, and giving own props child", async () => {
+  test("mix of slots, t-call, t-call with body, and giving own props child", async () => {
     expect.assertions(11);
 
     class C extends Component {
@@ -1836,7 +1836,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<button>inc</button>[B][C][A][sub1] [sub2334]");
   });
 
-  test.skip("slot in multiple locations", async () => {
+  test("slot in multiple locations", async () => {
     class Child extends Component {
       static template = xml`<div>child</div>`;
     }
@@ -1869,7 +1869,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe(" hello <div>child</div>");
   });
 
-  test.skip("dynamic slot in multiple locations", async () => {
+  test("dynamic slot in multiple locations", async () => {
     class Child extends Component {
       static template = xml`<div>child</div>`;
     }
@@ -1902,7 +1902,7 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("hello <div>child</div>");
   });
 
-  test.skip("slot in t-foreach locations", async () => {
+  test("slot in t-foreach locations", async () => {
     class Child extends Component {
       static template = xml`<div>child</div>`;
     }
@@ -1933,33 +1933,4 @@ describe("slots", () => {
       "<p>1 hello <div>child</div></p><p>2 hello <div>child</div></p>"
     );
   });
-
-  test.skip("conditional slot", async () => {
-    class Child extends Component {
-      static template = xml`<t t-slot="abc"/>`;
-    }
-
-    class Parent extends Component {
-      static template = xml`
-        <Child>
-          <t t-if="state.flag">
-            <t t-set-slot="abc">blue</t>
-          </t>
-          <t t-else="">
-            <t t-set-slot="abc">red</t>
-          </t>
-        </Child>`;
-      static components = { Child };
-      state = useState({ flag: true});
-    }
-    const parent = await mount(Parent, fixture);
-
-    expect(fixture.innerHTML).toBe("blue");
-    
-    parent.state.flag = false;
-    await nextTick();
-    expect(fixture.innerHTML).toBe("red");
-
-  });
-
 });