@esportsplus/template 0.20.4 → 0.22.0

package/build/attributes.d.ts

@@ -1,7 +1,11 @@
+import { STATE_HYDRATING, STATE_NONE, STATE_WAITING } from './constants.js';
 import { Attributes, Element } from './types.js';
+type State = typeof STATE_HYDRATING | typeof STATE_NONE | typeof STATE_WAITING;
+declare const set: (element: Element, name: string, value: unknown, state?: State) => void;
 declare const spread: (element: Element, value: Attributes | Attributes[]) => void;
 declare const _default: {
+    set: (element: Element, name: string, value: unknown, state?: State) => void;
     spread: (element: Element, value: Attributes | Attributes[]) => void;
 };
 export default _default;
-export { spread };
+export { set, spread };

package/build/attributes.js

@@ -102,7 +102,24 @@ function schedule(ctx, element, name, state, value) {
     scheduled = true;
     raf.add(task);
 }
-function set(element, name, value, state) {
+function task() {
+    let context, n = queue.length;
+    while ((context = queue.next()) && n--) {
+        let { element, updates } = context;
+        for (let name in updates) {
+            apply(element, name, updates[name]);
+        }
+        context.updates = {};
+        context.updating = false;
+    }
+    if (queue.length) {
+        raf.add(task);
+    }
+    else {
+        scheduled = false;
+    }
+}
+const set = (element, name, value, state = STATE_HYDRATING) => {
     let fn = name === 'class' || name === 'style' ? list : property, type = typeof value;
     if (type === 'function') {
         if (name.startsWith('on')) {
@@ -144,24 +161,7 @@ function set(element, name, value, state) {
         return;
     }
     fn(null, element, null, name, value, state);
-}
-function task() {
-    let context, n = queue.length;
-    while ((context = queue.next()) && n--) {
-        let { element, updates } = context;
-        for (let name in updates) {
-            apply(element, name, updates[name]);
-        }
-        context.updates = {};
-        context.updating = false;
-    }
-    if (queue.length) {
-        raf.add(task);
-    }
-    else {
-        scheduled = false;
-    }
-}
+};
 const spread = function (element, value) {
     if (isObject(value)) {
         for (let name in value) {
@@ -169,7 +169,7 @@ const spread = function (element, value) {
             if (v == null || v === false || v === '') {
                 continue;
             }
-            set(element, name, v, STATE_HYDRATING);
+            set(element, name, v);
         }
     }
     else if (isArray(value)) {
@@ -178,5 +178,5 @@ const spread = function (element, value) {
         }
     }
 };
-export default { spread };
-export { spread };
+export default { set, spread };
+export { set, spread };

package/build/constants.d.ts

@@ -6,13 +6,14 @@ declare const NODE_SLOT = 4;
 declare const NODE_VOID = 5;
 declare const NODE_WHITELIST: Record<string, number>;
 declare const REGEX_EMPTY_TEXT_NODES: RegExp;
+declare const REGEX_EVENTS: RegExp;
+declare const REGEX_SLOT_ATTRIBUTES: RegExp;
 declare const REGEX_SLOT_NODES: RegExp;
 declare const RENDERABLE: unique symbol;
 declare const RENDERABLE_HTML_REACTIVE_ARRAY = 1;
 declare const SLOT_HTML = "<!--$-->";
 declare const SLOT_MARKER = "{{$}}";
-declare const SLOT_MARKER_LENGTH: number;
 declare const STATE_HYDRATING = 0;
 declare const STATE_NONE = 1;
 declare const STATE_WAITING = 2;
-export { CLEANUP, EMPTY_FRAGMENT, NODE_CLOSING, NODE_ELEMENT, NODE_SLOT, NODE_VOID, NODE_WHITELIST, REGEX_EMPTY_TEXT_NODES, REGEX_SLOT_NODES, RENDERABLE, RENDERABLE_HTML_REACTIVE_ARRAY, SLOT_HTML, SLOT_MARKER, SLOT_MARKER_LENGTH, STATE_HYDRATING, STATE_NONE, STATE_WAITING };
+export { CLEANUP, EMPTY_FRAGMENT, NODE_CLOSING, NODE_ELEMENT, NODE_SLOT, NODE_VOID, NODE_WHITELIST, REGEX_EMPTY_TEXT_NODES, REGEX_EVENTS, REGEX_SLOT_ATTRIBUTES, REGEX_SLOT_NODES, RENDERABLE, RENDERABLE_HTML_REACTIVE_ARRAY, SLOT_HTML, SLOT_MARKER, STATE_HYDRATING, STATE_NONE, STATE_WAITING };

package/build/constants.js

@@ -27,13 +27,14 @@ const NODE_WHITELIST = {
     'wbr': NODE_VOID
 };
 const REGEX_EMPTY_TEXT_NODES = /(>|})\s+(<|{)/g;
+const REGEX_EVENTS = /(?:\s*on[\w-:]+\s*=(?:\s*["'][^"']*["'])*)/g;
+const REGEX_SLOT_ATTRIBUTES = /<[\w-]+([^><]*{{\$}}[^><]*)>/g;
 const REGEX_SLOT_NODES = /<([\w-]+|[\/!])(?:([^><]*{{\$}}[^><]*)|(?:[^><]*))?>|{{\$}}/g;
 const RENDERABLE = Symbol();
 const RENDERABLE_HTML_REACTIVE_ARRAY = 1;
 const SLOT_HTML = '<!--$-->';
 const SLOT_MARKER = '{{$}}';
-const SLOT_MARKER_LENGTH = SLOT_MARKER.length;
 const STATE_HYDRATING = 0;
 const STATE_NONE = 1;
 const STATE_WAITING = 2;
-export { CLEANUP, EMPTY_FRAGMENT, NODE_CLOSING, NODE_ELEMENT, NODE_SLOT, NODE_VOID, NODE_WHITELIST, REGEX_EMPTY_TEXT_NODES, REGEX_SLOT_NODES, RENDERABLE, RENDERABLE_HTML_REACTIVE_ARRAY, SLOT_HTML, SLOT_MARKER, SLOT_MARKER_LENGTH, STATE_HYDRATING, STATE_NONE, STATE_WAITING };
+export { CLEANUP, EMPTY_FRAGMENT, NODE_CLOSING, NODE_ELEMENT, NODE_SLOT, NODE_VOID, NODE_WHITELIST, REGEX_EMPTY_TEXT_NODES, REGEX_EVENTS, REGEX_SLOT_ATTRIBUTES, REGEX_SLOT_NODES, RENDERABLE, RENDERABLE_HTML_REACTIVE_ARRAY, SLOT_HTML, SLOT_MARKER, STATE_HYDRATING, STATE_NONE, STATE_WAITING };

package/build/event/index.js

@@ -4,6 +4,7 @@ import { addEventListener } from '../utilities/element.js';
 import { parentElement } from '../utilities/node.js';
 import { ondisconnect } from '../slot/cleanup.js';
 import onconnect from './onconnect.js';
+import onresize from './onresize.js';
 import ontick from './ontick.js';
 let capture = new Set(['onblur', 'onfocus', 'onscroll']), controllers = new Map(), keys = {}, passive = new Set([
     'onmousedown', 'onmouseenter', 'onmouseleave', 'onmousemove', 'onmouseout', 'onmouseover', 'onmouseup', 'onmousewheel',
@@ -65,6 +66,9 @@ export default (element, event, listener) => {
         case 'ondisconnect':
             ondisconnect(element, () => listener(element));
             return;
+        case 'onresize':
+            onresize(element, listener);
+            return;
         case 'ontick':
             ontick(element, listener);
             return;

package/build/event/onresize.d.ts

@@ -0,0 +1,3 @@
+import { Element } from '../types.js';
+declare const _default: (element: Element, listener: Function) => void;
+export default _default;

package/build/event/onresize.js

@@ -0,0 +1,26 @@
+import { onCleanup } from '@esportsplus/reactivity';
+let listeners = new Map(), registered = false;
+function onresize() {
+    for (let [element, fn] of listeners) {
+        if (element.isConnected) {
+            fn(element);
+        }
+        else {
+            listeners.delete(element);
+        }
+    }
+    if (listeners.size === 0) {
+        window.removeEventListener('resize', onresize);
+        registered = false;
+    }
+}
+export default (element, listener) => {
+    listeners.set(element, listener);
+    onCleanup(() => {
+        listeners.delete(element);
+    });
+    if (!registered) {
+        window.addEventListener('resize', onresize);
+        registered = true;
+    }
+};

package/build/html/index.d.ts

@@ -1,6 +1,6 @@
 import { ReactiveArray } from '@esportsplus/reactivity';
-import { Attributes, Renderable, RenderableReactive } from '../types.js';
-type Values<T> = Attributes<any> | Renderable<T>;
+import { Attribute, Attributes, Renderable, RenderableReactive } from '../types.js';
+type Values<T> = Attribute | Attributes<any> | Renderable<T>;
 declare const html: {
     <T>(literals: TemplateStringsArray, ...values: (Values<T> | Values<T>[])[]): Node;
     reactive<T>(array: ReactiveArray<T>, template: RenderableReactive<T>["template"]): RenderableReactive<T>;

package/build/html/index.js

@@ -6,14 +6,14 @@ const html = (literals, ...values) => {
     if (slots !== null) {
         let node, nodePath;
         for (let i = slots.length - 1; i >= 0; i--) {
-            let { fn, path, slot } = slots[i];
+            let { fn, path } = slots[i];
             if (nodePath !== path) {
                 node = clone;
                 for (let i = 0, n = path.length; i < n; i++) {
                     node = path[i].call(node);
                 }
             }
-            fn(node, values[slot]);
+            fn(node, values[i]);
         }
     }
     return clone;

package/build/html/parser.js

@@ -1,8 +1,8 @@
-import { NODE_CLOSING, NODE_ELEMENT, NODE_SLOT, NODE_VOID, NODE_WHITELIST, REGEX_EMPTY_TEXT_NODES, REGEX_SLOT_NODES, SLOT_HTML, SLOT_MARKER, SLOT_MARKER_LENGTH } from '../constants.js';
+import { NODE_CLOSING, NODE_ELEMENT, NODE_SLOT, NODE_VOID, NODE_WHITELIST, REGEX_EMPTY_TEXT_NODES, REGEX_EVENTS, REGEX_SLOT_ATTRIBUTES, REGEX_SLOT_NODES, SLOT_HTML, SLOT_MARKER } from '../constants.js';
 import { firstElementChild, nextElementSibling } from '../utilities/element.js';
 import { firstChild, nextSibling } from '../utilities/node.js';
-import { spread } from '../attributes.js';
 import { fragment } from '../utilities/fragment.js';
+import a from '../attributes.js';
 import s from '../slot/index.js';
 let cache = new WeakMap();
 function build(literals) {
@@ -10,13 +10,67 @@ function build(literals) {
     if (n === 0) {
         return set(literals, literals[0]);
     }
-    let buffer = '', html = literals.join(SLOT_MARKER)
+    let attributes = {}, buffer = '', events = false, html = literals.join(SLOT_MARKER)
         .replace(REGEX_EMPTY_TEXT_NODES, '$1$2')
         .trim(), index = 0, level = 0, levels = [{
             children: 0,
             elements: 0,
             path: []
         }], parsed = html.split(SLOT_MARKER), slot = 0, slots = [];
+    {
+        let attribute = '', buffer = '', char = '', quote = '';
+        for (let match of html.matchAll(REGEX_SLOT_ATTRIBUTES)) {
+            let found = match[1], metadata = attributes[found];
+            if (metadata) {
+                continue;
+            }
+            metadata = attributes[found] = [];
+            for (let i = 0, n = found.length; i < n; i++) {
+                char = found[i];
+                if (char === ' ') {
+                    buffer = '';
+                }
+                else if (char === '=') {
+                    attribute = buffer;
+                    buffer = '';
+                }
+                else if (char === '"' || char === "'") {
+                    if (!attribute) {
+                        continue;
+                    }
+                    else if (!quote) {
+                        quote = char;
+                    }
+                    else if (quote === char) {
+                        attribute = '';
+                        buffer = '';
+                        quote = '';
+                    }
+                }
+                else if (char === '{' && char !== buffer) {
+                    buffer = char;
+                }
+                else {
+                    buffer += char;
+                    if (buffer === SLOT_MARKER) {
+                        buffer = '';
+                        if (attribute) {
+                            metadata.push(attribute);
+                            if (!quote) {
+                                attribute = '';
+                            }
+                        }
+                        else {
+                            metadata.push(null);
+                        }
+                    }
+                    else if (buffer === 'on') {
+                        events = true;
+                    }
+                }
+            }
+        }
+    }
     for (let match of html.matchAll(REGEX_SLOT_NODES)) {
         let parent = levels[level], type = match[1] === undefined ? NODE_SLOT : (NODE_WHITELIST[match[1].toLowerCase()] || NODE_ELEMENT);
         if ((match.index || 1) - 1 > index) {
@@ -27,15 +81,18 @@ function build(literals) {
                 ? methods(parent.elements, parent.path, firstElementChild, nextElementSibling)
                 : methods(parent.children, [], firstChild, nextSibling);
             if (attr) {
-                let i = attr.indexOf(SLOT_MARKER);
-                while (i !== -1) {
+                let metadata = attributes[attr];
+                if (!metadata) {
+                    throw new Error(`Template: attribute metadata could not be found for '${attr}'`);
+                }
+                for (let i = 0, n = metadata.length; i < n; i++) {
+                    let name = metadata[i];
                     slots.push({
-                        fn: spread,
-                        path,
-                        slot
+                        fn: name === null ? a.spread : a.set,
+                        name,
+                        path
                     });
                     buffer += parsed[slot++];
-                    i = attr.indexOf(SLOT_MARKER, i + SLOT_MARKER_LENGTH);
                 }
             }
             if (type === NODE_ELEMENT) {
@@ -48,14 +105,14 @@ function build(literals) {
             parent.elements++;
         }
         else if (type === NODE_SLOT) {
-            buffer += parsed[slot] + SLOT_HTML;
+            buffer += parsed[slot++] + SLOT_HTML;
             slots.push({
                 fn: s,
-                path: methods(parent.children, parent.path, firstChild, nextSibling),
-                slot: slot++
+                name: null,
+                path: methods(parent.children, parent.path, firstChild, nextSibling)
             });
         }
-        if (slot === n) {
+        if (n === slot) {
             buffer += parsed[slot];
             break;
         }
@@ -67,6 +124,9 @@ function build(literals) {
         }
         index = (match.index || 0) + match[0].length;
     }
+    if (events) {
+        buffer = buffer.replace(REGEX_EVENTS, '');
+    }
     return set(literals, buffer, slots);
 }
 function methods(children, copy, first, next) {

package/build/types.d.ts

@@ -4,7 +4,7 @@ import { firstChild } from './utilities/node.js';
 import attributes from './attributes.js';
 import slot from './slot/index.js';
 import html from './html/index.js';
-type Attribute = Effect<Primitive | Primitive[]> | Primitive;
+type Attribute = Effect<Primitive | Primitive[]> | (<T>(...args: T[]) => void) | Primitive;
 type Attributes<T extends HTMLElement = Element> = {
     [key: `aria-${string}`]: string | number | boolean | undefined;
     [key: `data-${string}`]: string | undefined;
@@ -12,10 +12,10 @@ type Attributes<T extends HTMLElement = Element> = {
     onconnect?: (element: T) => void;
     ondisconnect?: (element: T) => void;
     onrender?: (element: T) => void;
-    ontick?: (element: T) => void;
+    ontick?: (dispose: VoidFunction, element: T) => void;
     style?: Attribute | Attribute[];
 } & {
-    [K in keyof GlobalEventHandlersEventMap as `on${string & K}`]?: (this: HTMLElement, event: GlobalEventHandlersEventMap[K]) => void;
+    [K in keyof GlobalEventHandlersEventMap as `on${string & K}`]?: (this: T, event: GlobalEventHandlersEventMap[K]) => void;
 } & Record<PropertyKey, unknown>;
 type Effect<T> = () => T extends [] ? Renderable<T>[] : Renderable<T>;
 type Element = HTMLElement & Attributes<any>;
@@ -35,9 +35,9 @@ type Template = {
     html: string;
     literals: TemplateStringsArray;
     slots: {
-        fn: typeof attributes.spread | typeof slot;
+        fn: typeof attributes.set | typeof attributes.spread | typeof slot;
+        name: string | null;
         path: typeof firstChild[];
-        slot: number;
     }[] | null;
 };
-export type { Attributes, Effect, Element, Renderable, RenderableReactive, SlotGroup, Template };
+export type { Attribute, Attributes, Effect, Element, Renderable, RenderableReactive, SlotGroup, Template };

package/package.json

@@ -14,7 +14,7 @@
   "private": false,
   "type": "module",
   "types": "./build/index.d.ts",
-  "version": "0.20.4",
+  "version": "0.22.0",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"

package/src/attributes.ts

@@ -169,7 +169,31 @@ function schedule(ctx: Context | null, element: Element, name: string, state: St
     raf.add(task);
 }
 
-function set(element: Element, name: string, value: unknown, state: State) {
+function task() {
+    let context,
+        n = queue.length;
+
+    while ((context = queue.next()) && n--) {
+        let { element, updates } = context;
+
+        for (let name in updates) {
+            apply(element, name, updates[name]);
+        }
+
+        context.updates = {};
+        context.updating = false;
+    }
+
+    if (queue.length) {
+        raf.add(task);
+    }
+    else {
+        scheduled = false;
+    }
+}
+
+
+const set = (element: Element, name: string, value: unknown, state: State = STATE_HYDRATING) => {
     let fn = name === 'class' || name === 'style' ? list : property,
         type = typeof value;
 
@@ -233,31 +257,7 @@ function set(element: Element, name: string, value: unknown, state: State) {
     }
 
     fn(null, element, null, name, value, state);
-}
-
-function task() {
-    let context,
-        n = queue.length;
-
-    while ((context = queue.next()) && n--) {
-        let { element, updates } = context;
-
-        for (let name in updates) {
-            apply(element, name, updates[name]);
-        }
-
-        context.updates = {};
-        context.updating = false;
-    }
-
-    if (queue.length) {
-        raf.add(task);
-    }
-    else {
-        scheduled = false;
-    }
-}
-
+};
 
 const spread = function (element: Element, value: Attributes | Attributes[]) {
     if (isObject(value)) {
@@ -268,7 +268,7 @@ const spread = function (element: Element, value: Attributes | Attributes[]) {
                 continue;
             }
 
-            set(element, name, v, STATE_HYDRATING);
+            set(element, name, v);
         }
     }
     else if (isArray(value)) {
@@ -279,5 +279,5 @@ const spread = function (element: Element, value: Attributes | Attributes[]) {
 };
 
 
-export default { spread };
-export { spread };
+export default { set, spread };
+export { set, spread };

package/src/constants.ts

@@ -42,6 +42,10 @@ const NODE_WHITELIST: Record<string, number> = {
 
 const REGEX_EMPTY_TEXT_NODES = /(>|})\s+(<|{)/g;
 
+const REGEX_EVENTS = /(?:\s*on[\w-:]+\s*=(?:\s*["'][^"']*["'])*)/g;
+
+const REGEX_SLOT_ATTRIBUTES = /<[\w-]+([^><]*{{\$}}[^><]*)>/g;
+
 const REGEX_SLOT_NODES = /<([\w-]+|[\/!])(?:([^><]*{{\$}}[^><]*)|(?:[^><]*))?>|{{\$}}/g;
 
 
@@ -54,8 +58,6 @@ const SLOT_HTML = '<!--$-->';
 
 const SLOT_MARKER = '{{$}}';
 
-const SLOT_MARKER_LENGTH = SLOT_MARKER.length;
-
 
 const STATE_HYDRATING = 0;
 
@@ -68,8 +70,7 @@ export {
     CLEANUP,
     EMPTY_FRAGMENT,
     NODE_CLOSING, NODE_ELEMENT, NODE_SLOT, NODE_VOID, NODE_WHITELIST,
-    REGEX_EMPTY_TEXT_NODES, REGEX_SLOT_NODES,
+    REGEX_EMPTY_TEXT_NODES, REGEX_EVENTS, REGEX_SLOT_ATTRIBUTES, REGEX_SLOT_NODES,
     RENDERABLE, RENDERABLE_HTML_REACTIVE_ARRAY,
-    SLOT_HTML, SLOT_MARKER, SLOT_MARKER_LENGTH,
-    STATE_HYDRATING, STATE_NONE, STATE_WAITING
+    SLOT_HTML, SLOT_MARKER, STATE_HYDRATING, STATE_NONE, STATE_WAITING
 };

package/src/event/index.ts

@@ -5,6 +5,7 @@ import { addEventListener } from '~/utilities/element';
 import { parentElement } from '~/utilities/node';
 import { ondisconnect } from '~/slot/cleanup';
 import onconnect from './onconnect';
+import onresize from './onresize';
 import ontick from './ontick';
 
 
@@ -97,6 +98,10 @@ export default (element: Element, event: `on${string}`, listener: Function): voi
             ondisconnect(element, () => listener(element));
             return;
 
+        case 'onresize':
+            onresize(element, listener);
+            return;
+
         case 'ontick':
             ontick(element, listener);
             return;

package/src/event/onresize.ts

@@ -0,0 +1,37 @@
+import { onCleanup } from '@esportsplus/reactivity';
+import { Element } from '~/types';
+
+
+let listeners = new Map<Element, Function>(),
+    registered = false;
+
+
+function onresize() {
+    for (let [element, fn] of listeners) {
+        if (element.isConnected) {
+            fn(element);
+        }
+        else {
+            listeners.delete(element);
+        }
+    }
+
+    if (listeners.size === 0) {
+        window.removeEventListener('resize', onresize);
+        registered = false;
+    }
+}
+
+
+export default (element: Element, listener: Function) => {
+    listeners.set(element, listener);
+
+    onCleanup(() => {
+        listeners.delete(element);
+    });
+
+    if (!registered) {
+        window.addEventListener('resize', onresize);
+        registered = true;
+    }
+};

package/src/html/index.ts

@@ -1,11 +1,11 @@
 import { ReactiveArray } from '@esportsplus/reactivity';
 import { RENDERABLE, RENDERABLE_HTML_REACTIVE_ARRAY } from '~/constants';
-import { Attributes, Renderable, RenderableReactive } from '~/types';
+import { Attribute, Attributes, Renderable, RenderableReactive } from '~/types';
 import { cloneNode } from '~/utilities/node';
 import parser from './parser';
 
 
-type Values<T> = Attributes<any> | Renderable<T>;
+type Values<T> = Attribute | Attributes<any> | Renderable<T>;
 
 
 const html = <T>(literals: TemplateStringsArray, ...values: (Values<T> | Values<T>[])[]) => {
@@ -16,7 +16,7 @@ const html = <T>(literals: TemplateStringsArray, ...values: (Values<T> | Values<
         let node, nodePath;
 
         for (let i = slots.length - 1; i >= 0; i--) {
-            let { fn, path, slot } = slots[i];
+            let { fn, path } = slots[i];
 
             if (nodePath !== path) {
                 node = clone;
@@ -27,7 +27,7 @@ const html = <T>(literals: TemplateStringsArray, ...values: (Values<T> | Values<
             }
 
             // @ts-ignore
-            fn(node, values[slot]);
+            fn(node, values[i]);
         }
     }
 

package/src/html/parser.ts

@@ -1,12 +1,13 @@
 import {
-    NODE_CLOSING, NODE_ELEMENT, NODE_SLOT, NODE_VOID, NODE_WHITELIST, REGEX_EMPTY_TEXT_NODES,
-    REGEX_SLOT_NODES, SLOT_HTML, SLOT_MARKER, SLOT_MARKER_LENGTH
+    NODE_CLOSING, NODE_ELEMENT, NODE_SLOT, NODE_VOID, NODE_WHITELIST,
+    REGEX_EMPTY_TEXT_NODES, REGEX_EVENTS, REGEX_SLOT_ATTRIBUTES, REGEX_SLOT_NODES,
+    SLOT_HTML, SLOT_MARKER
 } from '~/constants';
 import { Template } from '~/types';
 import { firstElementChild, nextElementSibling } from '~/utilities/element';
 import { firstChild, nextSibling } from '~/utilities/node';
-import { spread } from '~/attributes';
 import { fragment } from '~/utilities/fragment';
+import a from '~/attributes';
 import s from '~/slot';
 
 
@@ -20,7 +21,9 @@ function build(literals: TemplateStringsArray) {
         return set(literals, literals[0]);
     }
 
-    let buffer = '',
+    let attributes: Record<string, (null | string)[]> = {},
+        buffer = '',
+        events = false,
         html = literals.join(SLOT_MARKER)
             .replace(REGEX_EMPTY_TEXT_NODES, '$1$2')
             .trim(),
@@ -35,6 +38,73 @@ function build(literals: TemplateStringsArray) {
         slot = 0,
         slots: Template['slots'] = [];
 
+    {
+        let attribute = '',
+            buffer = '',
+            char = '',
+            quote = '';
+
+        for (let match of html.matchAll(REGEX_SLOT_ATTRIBUTES)) {
+            let found = match[1],
+                metadata = attributes[found];
+
+            if (metadata) {
+                continue;
+            }
+
+            metadata = attributes[found] = [];
+
+            for (let i = 0, n = found.length; i < n; i++) {
+                char = found[i];
+
+                if (char === ' ') {
+                    buffer = '';
+                }
+                else if (char === '=') {
+                    attribute = buffer;
+                    buffer = '';
+                }
+                else if (char === '"' || char === "'") {
+                    if (!attribute) {
+                        continue;
+                    }
+                    else if (!quote) {
+                        quote = char;
+                    }
+                    else if (quote === char) {
+                        attribute = '';
+                        buffer = '';
+                        quote = '';
+                    }
+                }
+                else if (char === '{' && char !== buffer) {
+                    buffer = char;
+                }
+                else {
+                    buffer += char;
+
+                    if (buffer === SLOT_MARKER) {
+                        buffer = '';
+
+                        if (attribute) {
+                            metadata.push(attribute);
+
+                            if (!quote) {
+                                attribute = '';
+                            }
+                        }
+                        else {
+                            metadata.push(null);
+                        }
+                    }
+                    else if (buffer === 'on') {
+                        events = true;
+                    }
+                }
+            }
+        }
+    }
+
     for (let match of html.matchAll(REGEX_SLOT_NODES)) {
         let parent = levels[level],
             type = match[1] === undefined ? NODE_SLOT : (NODE_WHITELIST[match[1].toLowerCase()] || NODE_ELEMENT);
@@ -51,17 +121,22 @@ function build(literals: TemplateStringsArray) {
                     : methods(parent.children, [], firstChild, nextSibling);
 
             if (attr) {
-                let i = attr.indexOf(SLOT_MARKER);
+                let metadata = attributes[attr];
+
+                if (!metadata) {
+                    throw new Error(`Template: attribute metadata could not be found for '${attr}'`);
+                }
+
+                for (let i = 0, n = metadata.length; i < n; i++) {
+                    let name = metadata[i];
 
-                while (i !== -1) {
                     slots.push({
-                        fn: spread,
-                        path,
-                        slot
+                        fn: name === null ? a.spread : a.set,
+                        name,
+                        path
                     });
 
                     buffer += parsed[slot++];
-                    i = attr.indexOf(SLOT_MARKER, i + SLOT_MARKER_LENGTH);
                 }
             }
 
@@ -76,15 +151,15 @@ function build(literals: TemplateStringsArray) {
             parent.elements++;
         }
         else if (type === NODE_SLOT) {
-            buffer += parsed[slot] + SLOT_HTML;
+            buffer += parsed[slot++] + SLOT_HTML;
             slots.push({
                 fn: s,
-                path: methods(parent.children, parent.path, firstChild, nextSibling),
-                slot: slot++
+                name: null,
+                path: methods(parent.children, parent.path, firstChild, nextSibling)
             });
         }
 
-        if (slot === n) {
+        if (n === slot) {
             buffer += parsed[slot];
             break;
         }
@@ -99,6 +174,10 @@ function build(literals: TemplateStringsArray) {
         index = (match.index || 0) + match[0].length;
     }
 
+    if (events) {
+        buffer = buffer.replace(REGEX_EVENTS, '');
+    }
+
     return set(literals, buffer, slots);
 }
 

package/src/types.ts

@@ -6,7 +6,7 @@ import slot from './slot';
 import html from './html';
 
 
-type Attribute = Effect<Primitive | Primitive[]> | Primitive;
+type Attribute = Effect<Primitive | Primitive[]> | (<T>(...args: T[]) => void) | Primitive;
 
 type Attributes<T extends HTMLElement = Element> = {
     [key: `aria-${string}`]: string | number | boolean | undefined;
@@ -15,10 +15,10 @@ type Attributes<T extends HTMLElement = Element> = {
     onconnect?: (element: T) => void;
     ondisconnect?: (element: T) => void;
     onrender?: (element: T) => void;
-    ontick?: (element: T) => void;
+    ontick?: (dispose: VoidFunction, element: T) => void;
     style?: Attribute | Attribute[];
 } & {
-    [K in keyof GlobalEventHandlersEventMap as `on${string & K}`]?: (this: HTMLElement, event: GlobalEventHandlersEventMap[K]) => void;
+    [K in keyof GlobalEventHandlersEventMap as `on${string & K}`]?: (this: T, event: GlobalEventHandlersEventMap[K]) => void;
 } & Record<PropertyKey, unknown>;
 
 type Effect<T> = () => T extends [] ? Renderable<T>[] : Renderable<T>;
@@ -51,15 +51,15 @@ type Template = {
     html: string;
     literals: TemplateStringsArray;
     slots: {
-        fn: typeof attributes.spread | typeof slot;
+        fn: typeof attributes.set | typeof attributes.spread | typeof slot;
+        name: string | null;
         path: typeof firstChild[];
-        slot: number;
     }[] | null;
 };
 
 
 export type {
-    Attributes,
+    Attribute, Attributes,
     Effect, Element,
     Renderable, RenderableReactive,
     SlotGroup,