@microsoft/webui-framework 0.0.17 → 0.0.19

package/dist/template-events.d.ts

@@ -0,0 +1,6 @@
+import type { TemplateMeta } from './template.js';
+export declare const TEMPLATES_REGISTERED_EVENT = "webui:templates-registered";
+export declare function dispatchTemplatesRegistered(templates: Record<string, TemplateMeta>): void;
+export declare function templateRegistrationDetail(event: Event): {
+    templates?: Record<string, TemplateMeta>;
+} | undefined;

package/dist/template-events.js

@@ -0,0 +1,23 @@
+export const TEMPLATES_REGISTERED_EVENT = 'webui:templates-registered';
+export function dispatchTemplatesRegistered(templates) {
+    if (typeof window === 'undefined' ||
+        typeof CustomEvent !== 'function' ||
+        typeof window.dispatchEvent !== 'function') {
+        return;
+    }
+    window.dispatchEvent(new CustomEvent(TEMPLATES_REGISTERED_EVENT, {
+        detail: { templates },
+    }));
+}
+export function templateRegistrationDetail(event) {
+    const detail = event.detail;
+    if (!detail || typeof detail !== 'object')
+        return undefined;
+    const templates = detail.templates;
+    const payload = {
+        templates: typeof templates === 'object' && templates !== null
+            ? templates
+            : undefined,
+    };
+    return payload.templates ? payload : undefined;
+}

package/dist/template-roots.d.ts

@@ -0,0 +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 templateNeedsStaticHost(meta: TemplateMeta): boolean;

package/dist/template-roots.js

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

package/dist/template-types.d.ts

@@ -1,7 +1,3 @@
-/**
- * Template type definitions — shared across packages without pulling in
- * the global `Window` augmentation from `template.ts`.
- */
 export type CompiledAttrPart = string | [path: string];
 export type TemplateNodePath = number[];
 export type TemplateSlotPath = [
@@ -15,24 +11,28 @@ export type CompiledAttrGroupMeta = [
     start: number,
     count: number
 ];
-/**
- * Compiled condition — JSON metadata carries a function index plus the paths it
- * references. The Rust compiler emits the actual function bodies in a separate
- * closure array, and the runtime normalizes indexes to functions once.
- *
- * - `[0]` — evaluator function or component-local function index
- * - `[1]` — referenced paths for the reactive path index
- */
 export type CompiledConditionFn = (v: (path: string, s?: unknown) => unknown, s?: unknown) => boolean;
 export type CompiledCondition = [fn: CompiledConditionFn, paths: string[]];
 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 CompiledEventMeta = [name: string, handler: string, args: CompiledEventArgs, target: TemplateNodePath];
+export type CompiledEventBindingMeta = [
+    handler: string,
+    args: CompiledEventArgs,
+    target: TemplateNodePath,
+    usesEvent?: 1
+];
+export type CompiledEventGroupMeta = [name: string, bindings: CompiledEventBindingMeta[]];
 export interface TemplateBlockMeta {
     h: string;
     tx?: CompiledTextRunMeta[];
@@ -40,12 +40,14 @@ export interface TemplateBlockMeta {
     ag?: CompiledAttrGroupMeta[];
     c?: CompiledConditionalMeta[];
     r?: CompiledRepeatMeta[];
-    e?: CompiledEventMeta[];
+    eg?: CompiledEventGroupMeta[];
 }
 export interface TemplateMeta extends TemplateBlockMeta {
     b?: TemplateBlockMeta[];
     sa?: string;
     re?: [string, string, CompiledEventArgs][];
-    /** Shadow DOM flag — when true, client-created components use shadow root. */
+    tr?: string[];
+    ta?: string[];
     sd?: boolean;
+    th?: boolean | 1;
 }

package/dist/template-types.js

@@ -1,3 +1 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
 export {};

package/dist/template.d.ts

@@ -1,31 +1,16 @@
-/**
- * Template registry — stores compiled metadata objects from the Rust compiler.
- *
- * Each entry is a metadata object with:
- * - `h`  — static HTML for the component template
- * - `tx` — text runs `[slot, parts]` for text binding positions
- * - `a`  — attribute binding metadata
- * - `ag` — attribute target groups `[path, startIndex, count]`
- * - `c`  — conditional blocks `[conditionRef, blockIndex, slot]`
- * - `r`  — repeat/for blocks `[collection, itemVar, blockIndex, slot]`
- * - `e`  — element events `[eventName, handlerName, argSpecs, targetPath]`
- * - `b`  — nested compiled block metadata
- * - `sa` — adopted stylesheet specifier for CSS module strategy
- * - `sd` — shadow DOM flag for client-created components
- * - `re` — root events on the host element
- */
-export type { CompiledAttrGroupMeta, CompiledAttrMeta, CompiledAttrPart, CompiledCondition, CompiledConditionFn, CompiledConditionalMeta, CompiledEventArg, CompiledEventArgs, SerializedCompiledCondition, TemplateCondition, CompiledTextRunMeta, TemplateBlockMeta, TemplateMeta, TemplateNodePath, TemplateSlotPath, } from './template-types.js';
+export type { CompiledAttrGroupMeta, CompiledAttrMeta, CompiledAttrPart, CompiledCondition, CompiledConditionFn, CompiledConditionalMeta, CompiledEventArg, CompiledEventArgs, CompiledEventBindingMeta, CompiledEventGroupMeta, SerializedCompiledCondition, TemplateCondition, CompiledTextRunMeta, TemplateBlockMeta, TemplateMeta, TemplateNodePath, TemplateSlotPath, } from './template-types.js';
 import type { CompiledConditionFn, TemplateMeta } from './template-types.js';
 declare global {
     interface Window {
-        /** Consolidated SSR metadata loaded from `#webui-data` or partial responses. */
         __webui?: {
             state?: Record<string, unknown>;
             templates?: Record<string, TemplateMeta>;
             templateFns?: Record<string, CompiledConditionFn[]>;
+            templateHostExclusions?: Set<string>;
             [key: string]: unknown;
         };
     }
 }
 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;

package/dist/template.js

@@ -1,5 +1,4 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
+import { dispatchTemplatesRegistered } from './template-events.js';
 const WEBUI_DATA_ID = 'webui-data';
 const normalizedTemplates = new WeakSet();
 let webuiDataLoaded = false;
@@ -13,6 +12,10 @@ export function getTemplate(name) {
         normalizeTemplate(name, meta);
     return meta;
 }
+export function getTemplateRegistry() {
+    loadWebUIDataBlock();
+    return window.__webui?.templates;
+}
 export function registerTemplateData(templates, templateFns) {
     const w = window;
     if (!w.__webui)
@@ -29,12 +32,16 @@ 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)
+        dispatchTemplatesRegistered(templates);
 }
 function loadWebUIDataBlock() {
     if (webuiDataLoaded || window.__webui?.state !== undefined || typeof document === 'undefined')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/webui-framework",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "type": "module",
   "description": "WebUI Framework Next — Preact-inspired lightweight Web Component runtime with SSR hydration. 15KB minified, compiled-template path mapping, no hydration markers.",
   "license": "MIT",
@@ -10,16 +10,22 @@
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
       }
+    },
+    "./component-asset.js": {
+      "import": {
+        "types": "./dist/component-asset.d.ts",
+        "default": "./dist/component-asset.js"
+      }
     }
   },
   "files": [
     "dist/"
   ],
   "devDependencies": {
-    "@playwright/test": "^1.58.2",
-    "@types/node": "^25.3.5",
-    "typescript": "^5.9.3",
-    "@microsoft/webui-test-support": "0.0.17"
+    "@playwright/test": "^1.61.1",
+    "@types/node": "^26.1.0",
+    "typescript": "^6.0.3",
+    "@microsoft/webui-test-support": "0.0.19"
   },
   "scripts": {
     "build": "tsc",