quarkusio · gastaldi · Apr 13, 2023 · Apr 13, 2023
diff --git a/...sions/qute/deployment/src/main/java/io/quarkus/qute/deployment/TemplateDataBuildItem.java b/...sions/qute/deployment/src/main/java/io/quarkus/qute/deployment/TemplateDataBuildItem.java
@@ -25,7 +25,7 @@ public final class TemplateDataBuildItem extends MultiBuildItem {
     private final boolean properties;
     private final AnnotationInstance annotationInstance;
 
-    TemplateDataBuildItem(AnnotationInstance annotationInstance, ClassInfo targetClass) {
+    public TemplateDataBuildItem(AnnotationInstance annotationInstance, ClassInfo targetClass) {
         this.annotationInstance = annotationInstance;
 
         AnnotationValue ignoreValue = annotationInstance.value(ValueResolverGenerator.IGNORE);

diff --git a/...ns/qute/deployment/src/main/java/io/quarkus/qute/deployment/devui/QuteDevUIProcessor.java b/...ns/qute/deployment/src/main/java/io/quarkus/qute/deployment/devui/QuteDevUIProcessor.java
@@ -1,9 +1,12 @@
 package io.quarkus.qute.deployment.devui;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map.Entry;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 import org.jboss.jandex.DotName;
@@ -15,8 +18,10 @@
 import io.quarkus.devui.spi.page.Page;
 import io.quarkus.qute.ParameterDeclaration;
 import io.quarkus.qute.deployment.CheckedTemplateBuildItem;
+import io.quarkus.qute.deployment.ImplicitValueResolverBuildItem;
 import io.quarkus.qute.deployment.TemplateDataBuildItem;
 import io.quarkus.qute.deployment.TemplateExtensionMethodBuildItem;
+import io.quarkus.qute.deployment.TemplateGlobalBuildItem;
 import io.quarkus.qute.deployment.TemplatePathBuildItem;
 import io.quarkus.qute.deployment.TemplateVariantsBuildItem;
 import io.quarkus.qute.deployment.TemplatesAnalysisBuildItem;
@@ -34,13 +39,16 @@ public void pages(
             TemplatesAnalysisBuildItem templatesAnalysis,
             List<TemplateExtensionMethodBuildItem> templateExtensionMethods,
             List<TemplateDataBuildItem> templateDatas,
+            List<ImplicitValueResolverBuildItem> implicitTemplateDatas,
+            List<TemplateGlobalBuildItem> templateGlobals,
             BuildProducer<CardPageBuildItem> cardPages) {
 
         CardPageBuildItem pageBuildItem = new CardPageBuildItem();
 
         List<TemplatePathBuildItem> sortedTemplatePaths = templatePaths.stream()
                 .sorted(Comparator.comparing(tp -> tp.getPath().toLowerCase())).collect(Collectors.toList());
-        JsonArray templates = createTemplatesJson(sortedTemplatePaths, checkedTemplates, templatesAnalysis, variants);
+        pageBuildItem.addBuildTimeData("templates",
+                createTemplatesJson(sortedTemplatePaths, checkedTemplates, templatesAnalysis, variants));
 
         List<TemplateExtensionMethodBuildItem> sortedExtensionMethods = templateExtensionMethods.stream()
                 .sorted(new Comparator<TemplateExtensionMethodBuildItem>() {
@@ -53,37 +61,73 @@ public int compare(TemplateExtensionMethodBuildItem m1, TemplateExtensionMethodB
                         return ret == 0 ? m1.getMethod().name().compareTo(m2.getMethod().name()) : ret;
                     }
                 }).collect(Collectors.toList());
-        JsonArray extensionMethods = createExtensionMethodsJson(sortedExtensionMethods);
+        pageBuildItem.addBuildTimeData("extensionMethods", createExtensionMethodsJson(sortedExtensionMethods));
 
-        List<TemplateDataBuildItem> sortedTemplateData = templateDatas.stream()
+        List<TemplateDataBuildItem> sortedTemplateData = new ArrayList<>(templateDatas);
+        Set<DotName> explicitTargets = new HashSet<>();
+        for (TemplateDataBuildItem td : templateDatas) {
+            explicitTargets.add(td.getTargetClass().name());
+        }
+        for (ImplicitValueResolverBuildItem itd : implicitTemplateDatas) {
+            if (!explicitTargets.contains(itd.getClazz().name())) {
+                sortedTemplateData.add(new TemplateDataBuildItem(itd.getTemplateData(), itd.getClazz()));
+            }
+        }
+        sortedTemplateData = sortedTemplateData.stream()
                 .sorted(Comparator.comparing(td -> td.getTargetClass().name())).collect(Collectors.toList());
-        JsonArray templateData = createTemplateDataJson(sortedTemplateData);
+        if (!sortedTemplateData.isEmpty()) {
+            pageBuildItem.addBuildTimeData("templateData", createTemplateDataJson(sortedTemplateData));
+        }
 
-        pageBuildItem.addBuildTimeData("templates", templates);
-        pageBuildItem.addBuildTimeData("extensionMethods", extensionMethods);
-        pageBuildItem.addBuildTimeData("templateData", templateData);
+        List<TemplateGlobalBuildItem> sortedTemplateGlobals = templateGlobals.stream()
+                .sorted(Comparator.comparing(tg -> tg.getName().toLowerCase())).collect(Collectors.toList());
+        if (!sortedTemplateGlobals.isEmpty()) {
+            pageBuildItem.addBuildTimeData("templateGlobals", createTemplateGlobalsJson(sortedTemplateGlobals));
+        }
 
         pageBuildItem.addPage(Page.webComponentPageBuilder()
                 .title("Templates")
                 .icon("font-awesome-solid:file-code")
                 .componentLink("qwc-qute-templates.js")
-                .staticLabel(String.valueOf(templates.size())));
+                .staticLabel(String.valueOf(sortedTemplatePaths.size())));
 
         pageBuildItem.addPage(Page.webComponentPageBuilder()
                 .title("Extension Methods")
                 .icon("font-awesome-solid:puzzle-piece")
                 .componentLink("qwc-qute-extension-methods.js")
-                .staticLabel(String.valueOf(extensionMethods.size())));
+                .staticLabel(String.valueOf(sortedExtensionMethods.size())));
+
+        if (!sortedTemplateData.isEmpty()) {
+            pageBuildItem.addPage(Page.webComponentPageBuilder()
+                    .title("Template Data")
+                    .icon("font-awesome-solid:database")
+                    .componentLink("qwc-qute-template-data.js")
+                    .staticLabel(String.valueOf(sortedTemplateData.size())));
+        }
 
-        pageBuildItem.addPage(Page.webComponentPageBuilder()
-                .title("@TemplateData")
-                .icon("font-awesome-solid:database")
-                .componentLink("qwc-qute-template-data.js")
-                .staticLabel(String.valueOf(templateData.size())));
+        if (!sortedTemplateGlobals.isEmpty()) {
+            pageBuildItem.addPage(Page.webComponentPageBuilder()
+                    .title("Global Variables")
+                    .icon("font-awesome-solid:globe")
+                    .componentLink("qwc-qute-template-globals.js")
+                    .staticLabel(String.valueOf(sortedTemplateGlobals.size())));
+        }
 
         cardPages.produce(pageBuildItem);
     }
 
+    private JsonArray createTemplateGlobalsJson(List<TemplateGlobalBuildItem> sortedTemplateGlobals) {
+        JsonArray globals = new JsonArray();
+        for (TemplateGlobalBuildItem global : sortedTemplateGlobals) {
+            JsonObject json = new JsonObject();
+            json.put("name", global.getName());
+            json.put("target", global.getDeclaringClass() + "#"
+                    + (global.isField() ? global.getTarget().asField().name() : global.getTarget().asMethod().name() + "()"));
+            globals.add(json);
+        }
+        return globals;
+    }
+
     private JsonArray createTemplateDataJson(List<TemplateDataBuildItem> sortedTemplateData) {
         JsonArray data = new JsonArray();
         for (TemplateDataBuildItem templateData : sortedTemplateData) {

diff --git a/extensions/qute/deployment/src/main/resources/dev-ui/qwc-qute-template-data.js b/extensions/qute/deployment/src/main/resources/dev-ui/qwc-qute-template-data.js
@@ -4,6 +4,7 @@ import { columnBodyRenderer } from '@vaadin/grid/lit.js';
 import '@vaadin/grid';
 import '@vaadin/text-field';
 import { templateData } from 'build-time-data';
+import 'qui-alert';
 
 
 /**
@@ -32,6 +33,7 @@ export class QwcQuteTemplateData extends LitElement {
 
     render() {
             return html`
+                <qui-alert>The listed target classes are accessible in templates, i.e. a value resolver is generated for each class so that reflection is not needed to access properties and call methods.</qui-alert>
                 <vaadin-grid .items="${templateData}" class="templates-table" theme="no-border" all-rows-visible>
                     <vaadin-grid-column auto-width
                         header="Target Class"
@@ -44,7 +46,7 @@ export class QwcQuteTemplateData extends LitElement {
                         resizable>
                     </vaadin-grid-column>
                     <vaadin-grid-column auto-width
-                        header="Ignore"
+                        header="Ignore members"
                         ${columnBodyRenderer(this._renderIgnores, [])}
                         resizable>
                     </vaadin-grid-column>

diff --git a/extensions/qute/deployment/src/main/resources/dev-ui/qwc-qute-template-globals.js b/extensions/qute/deployment/src/main/resources/dev-ui/qwc-qute-template-globals.js
@@ -0,0 +1,64 @@
+
+import { LitElement, html, css} from 'lit';
+import { columnBodyRenderer } from '@vaadin/grid/lit.js';
+import '@vaadin/grid';
+import '@vaadin/text-field';
+import { templateGlobals } from 'build-time-data';
+
+
+/**
+ * This component shows the TemplateGlobal.
+ */
+export class QwcQuteTemplateGlobals extends LitElement {
+
+    static styles = css`
+       :host {
+          display: flex;
+          flex-direction: column;
+          gap: 10px;
+        }
+        .templates-table {
+          padding-bottom: 10px;
+          height: 100%;
+        }
+        code {
+          font-size: 85%;
+        }
+        .annotation {
+          color: var(--lumo-contrast-50pct);
+        }
+        `;
+
+
+    render() {
+            return html`
+                <qui-alert>Global variables are accessible in every template, i.e. a global variable named <code>foo</code> can be used like: <code>{foo}</code>.</qui-alert>
+                <vaadin-grid .items="${templateGlobals}" class="templates-table" theme="no-border" all-rows-visible>
+                    <vaadin-grid-column auto-width
+                        header="Name"
+                        ${columnBodyRenderer(this._renderName, [])}
+                        resizable>
+                    </vaadin-grid-column>
+                    <vaadin-grid-column auto-width
+                        header="Target"
+                        ${columnBodyRenderer(this._renderTarget, [])}
+                        resizable>
+                    </vaadin-grid-column>
+                </vaadin-grid>
+                `;
+    }
+
+    _renderTarget(global) {
+        return html`
+            <code>${global.target}</code>
+        `;
+    }
+
+    _renderName(global) {
+        return html`
+            <code>${global.name}</code>
+        `;
+    }
+
+}
+customElements.define('qwc-qute-template-globals', QwcQuteTemplateGlobals);