@microsoft/webui-framework 0.0.18 → 0.0.20

package/dist/template-events.js

@@ -13,7 +13,7 @@ export function templateRegistrationDetail(event) {
     const detail = event.detail;
     if (!detail || typeof detail !== 'object')
         return undefined;
-    const templates = detail?.templates;
+    const templates = detail.templates;
     const payload = {
         templates: typeof templates === 'object' && templates !== null
             ? templates

package/dist/template-roots.d.ts

@@ -1,5 +1,4 @@
 import type { TemplateMeta } from './template.js';
 export declare function templateHasRoot(meta: TemplateMeta, root: string): boolean;
 export declare function templateRootForAttribute(meta: TemplateMeta, attrName: string): string | undefined;
-export declare function templateAttributeForRoot(meta: TemplateMeta, root: string): string | undefined;
 export declare function templateNeedsStaticHost(meta: TemplateMeta): boolean;

package/dist/template-roots.js

@@ -19,17 +19,6 @@ export function templateRootForAttribute(meta, attrName) {
     }
     return undefined;
 }
-export function templateAttributeForRoot(meta, root) {
-    const roots = meta.tr;
-    const attrs = meta.ta;
-    if (!roots || !attrs)
-        return undefined;
-    for (let i = 0; i < roots.length && i < attrs.length; i++) {
-        if (roots[i] === root)
-            return attrs[i];
-    }
-    return undefined;
-}
 export function templateNeedsStaticHost(meta) {
     return !!meta.th;
 }

package/dist/template-types.d.ts

@@ -17,7 +17,13 @@ export type SerializedCompiledCondition = [fnIndex: number, paths: string[]];
 export type TemplateCondition = CompiledCondition | SerializedCompiledCondition;
 export type CompiledConditionalMeta = [condition: TemplateCondition, blockIndex: number, slot: TemplateSlotPath];
 export type CompiledAttrMeta = [name: string, kind: 0, value: string] | [name: string, kind: 1, value: string] | [name: string, kind: 2, condition: TemplateCondition] | [name: string, kind: 3, parts: CompiledAttrPart[]];
-export type CompiledRepeatMeta = [collection: string, itemVar: string, blockIndex: number, slot: TemplateSlotPath];
+export type CompiledRepeatMeta = [
+    collection: string,
+    itemVar: string,
+    blockIndex: number,
+    slot: TemplateSlotPath,
+    keyPath?: string
+];
 export type CompiledEventArg = ['e'] | ['p', string] | ['s', string] | ['n', number] | ['b', number] | ['z'];
 export type CompiledEventArgs = CompiledEventArg[];
 export type CompiledEventBindingMeta = [

package/dist/template.d.ts

@@ -6,6 +6,7 @@ declare global {
             state?: Record<string, unknown>;
             templates?: Record<string, TemplateMeta>;
             templateFns?: Record<string, CompiledConditionFn[]>;
+            templateHostExclusions?: Set<string>;
             [key: string]: unknown;
         };
     }
@@ -13,3 +14,4 @@ declare global {
 export declare function getTemplate(name: string): TemplateMeta | undefined;
 export declare function getTemplateRegistry(): Record<string, TemplateMeta> | undefined;
 export declare function registerTemplateData(templates: Record<string, TemplateMeta>, templateFns?: Record<string, CompiledConditionFn[]>): void;
+export declare function deferTemplateDefinition(tagName: string, ctor: Function, define: () => void): void;

package/dist/template.js

@@ -1,22 +1,9 @@
-import { dispatchTemplatesRegistered } from './template-events.js';
+import { dispatchTemplatesRegistered, templateRegistrationDetail, TEMPLATES_REGISTERED_EVENT, } from './template-events.js';
 const WEBUI_DATA_ID = 'webui-data';
 const normalizedTemplates = new WeakSet();
 let webuiDataLoaded = false;
-export function getTemplate(name) {
-    let meta = window.__webui?.templates?.[name];
-    if (!meta) {
-        loadWebUIDataBlock();
-        meta = window.__webui?.templates?.[name];
-    }
-    if (meta)
-        normalizeTemplate(name, meta);
-    return meta;
-}
-export function getTemplateRegistry() {
-    loadWebUIDataBlock();
-    return window.__webui?.templates;
-}
-export function registerTemplateData(templates, templateFns) {
+const pendingTemplateDefinitions = new Map();
+function acceptTemplateData(templates, templateFns) {
     const w = window;
     if (!w.__webui)
         w.__webui = {};
@@ -32,16 +19,56 @@ export function registerTemplateData(templates, templateFns) {
         }
     }
     const names = Object.keys(templates);
-    let hasTemplates = false;
     for (let i = 0; i < names.length; i++) {
         const tag = names[i];
         const meta = templates[tag];
         w.__webui.templates[tag] = meta;
         normalizeTemplate(tag, meta);
-        hasTemplates = true;
     }
-    if (hasTemplates)
+    for (let i = 0; i < names.length; i++) {
+        const pending = pendingTemplateDefinitions.get(names[i]);
+        if (!pending)
+            continue;
+        pendingTemplateDefinitions.delete(names[i]);
+        pending.define();
+    }
+    return names.length > 0;
+}
+if (typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
+    window.addEventListener(TEMPLATES_REGISTERED_EVENT, (event) => {
+        const templates = templateRegistrationDetail(event)?.templates;
+        if (templates)
+            acceptTemplateData(templates);
+    });
+}
+export function getTemplate(name) {
+    let meta = window.__webui?.templates?.[name];
+    if (!meta) {
+        loadWebUIDataBlock();
+        meta = window.__webui?.templates?.[name];
+    }
+    if (meta)
+        normalizeTemplate(name, meta);
+    return meta;
+}
+export function getTemplateRegistry() {
+    loadWebUIDataBlock();
+    return window.__webui?.templates;
+}
+export function registerTemplateData(templates, templateFns) {
+    if (acceptTemplateData(templates, templateFns)) {
         dispatchTemplatesRegistered(templates);
+    }
+}
+export function deferTemplateDefinition(tagName, ctor, define) {
+    const pending = pendingTemplateDefinitions.get(tagName);
+    if (pending) {
+        if (pending.ctor === ctor) {
+            throw new Error(`[WebUI] <${tagName}> is already pending definition.`);
+        }
+        throw new Error(`[WebUI] <${tagName}> already has a pending authored definition.`);
+    }
+    pendingTemplateDefinitions.set(tagName, { ctor, define });
 }
 function loadWebUIDataBlock() {
     if (webuiDataLoaded || window.__webui?.state !== undefined || typeof document === 'undefined')

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@microsoft/webui-framework",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "type": "module",
-  "description": "WebUI Framework Next — Preact-inspired lightweight Web Component runtime with SSR hydration. 15KB minified, compiled-template path mapping, no hydration markers.",
+  "description": "WebUI Framework Next — Preact-inspired lightweight Web Component runtime with SSR hydration and compiled-template path mapping.",
   "license": "MIT",
   "exports": {
     ".": {
@@ -16,6 +16,12 @@
         "types": "./dist/component-asset.d.ts",
         "default": "./dist/component-asset.js"
       }
+    },
+    "./streaming.js": {
+      "import": {
+        "types": "./dist/streaming-entry.d.ts",
+        "default": "./dist/streaming-entry.js"
+      }
     }
   },
   "files": [
@@ -25,7 +31,7 @@
     "@playwright/test": "^1.61.1",
     "@types/node": "^26.1.0",
     "typescript": "^6.0.3",
-    "@microsoft/webui-test-support": "0.0.18"
+    "@microsoft/webui-test-support": "0.0.20"
   },
   "scripts": {
     "build": "tsc",