@theotherwillembotha/node-red-plugincore 0.1.0 → 0.3.0

package/src/core/NodeGenerator.ts

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
+import * as path from 'path';
 
-import { buildNode, Template, NodeDescriptor, BaseService, ServiceDescriptor, BaseNode, DependencyType, TemplateDescriptor } from "./NodeConstructor"
+import { buildNode, buildNodeBuilder, Template, NodeDescriptor, BaseService, ServiceDescriptor, BaseNode, DependencyType, TemplateDescriptor } from "./NodeConstructor"
 
 const templatePropertyKeys = ["onIncludeOnce", "onIncludeDefaults", "onIncludeEditPrepare", "onIncludeEditPrepare", "onIncludeEditSave", "onIncludeEditForm"];
 
@@ -57,12 +58,10 @@ class NodeGenerator {
 
     public registerTemplate(template: ITemplateClass): NodeGenerator {
         try{
-            // verify that we dont already have this template.
             let descriptor = template.getTemplateDescriptor();
             if(!this._templates.map(t => t.name()).includes(descriptor.name())){
                 this._templates.push(descriptor);
-                // FIXME: skip recursive dependency resolution for now.
-                // descriptor.dependencies().forEach(dependency => this.addDependency(dependency));
+                descriptor.dependencies().forEach(dependency => this.addDependency(dependency));
             }
         }
         catch(error){
@@ -74,14 +73,14 @@ class NodeGenerator {
 
     public registerNode(node:INodeClass):NodeGenerator{
         try{
-            // verify that we have dont already have this node.
             let descriptor = node.getNodeDescriptor();
             if(!this._nodes[descriptor.id()]){
                 this._nodes[descriptor.id()] = {nodeClass:node, descriptor:descriptor};
-                // skip the recursive dependencies for now.
-                //descriptor.dependencies().forEach(dependency => this.addDependency(dependency));
+                // resolve templates declared in @NodeDescription
+                descriptor.templates().forEach(t => this.registerTemplate(t.template));
+                // resolve explicit dependencies (services, nodes, templates)
+                descriptor.dependencies().forEach(dependency => this.addDependency(dependency));
             }
-
         }
         catch(error){
             console.log("ERROR:", error);
@@ -89,13 +88,12 @@ class NodeGenerator {
         return this;
     }
 
-    public registerService(service: IServiceClass):NodeGenerator { 
+    public registerService(service: IServiceClass):NodeGenerator {
         try{
             let descriptor = service.getServiceDescriptor();
             if(!this._services.map(s => s.name()).includes(descriptor.name())){
                 this._services.push(descriptor);
-                // FIXME: skip recursive dependency resolution for now.
-                //descriptor.dependencies().forEach(dependency => this.addDependency(dependency));
+                descriptor.dependencies().forEach(dependency => this.addDependency(dependency));
             }
         }
         catch(error){
@@ -104,33 +102,22 @@ class NodeGenerator {
         return this;
     }
 
-    public generate(nodesOutputFile:string, pluginsOutputFile:string){
-        // STEP 1. Compile the templates.
-        // let templateInclude =  this._templates
-        //     .map(template => new (template.clazz()))
-        //     .map(template => {
-        //         return template.onIncludeOnce();
-        //     })
-        //     .join("\n");
-        let templateInclude = ""
-        
-        // STEP 2. compose the HTMLStructure of each of the nodes.
-        let nodeHTMLOutut = Object.values(this._nodes)
-            .map(node => {
-                console.log(`Processing node: ${node.descriptor.id()}`);
-
-                return buildNode(node.nodeClass);
-            })
-            .join("\n")
+    public generate(nodesOutputFile:string, pluginsOutputFile:string, packageName:string){
+        // Partition nodes into owned (belongs to this package) vs shared (from dependencies).
+        // Owned nodes get standard registerType + data-template-name in Nodes.html so that
+        // Node-RED's registry maps them to this module (enabling palette icons, flow library
+        // detection, etc.). Shared nodes keep the deferred pattern in Plugins.html to avoid
+        // HTML-scanning conflicts when multiple plugins bundle the same infrastructure nodes.
+        const allNodes = Object.values(this._nodes);
+        const ownedNodes = allNodes.filter(node => node.descriptor.package() === packageName);
+        const sharedNodes = allNodes.filter(node => node.descriptor.package() !== packageName);
 
-        fs.writeFileSync(nodesOutputFile + ".html",`
-<!--
-${NodeGenerator.warning}
--->
-${templateInclude}
-${nodeHTMLOutut}
+        console.log(`\nPackage: ${packageName}`);
+        console.log(`  Owned nodes (→ Nodes.html):   ${ownedNodes.map(n => n.descriptor.id()).join(', ') || '(none)'}`);
+        console.log(`  Shared nodes (→ Plugins.html): ${sharedNodes.map(n => n.descriptor.id()).join(', ') || '(none)'}\n`);
 
-        `);
+        // STEP 1. Generate Nodes.html with standard client-side definitions for owned nodes.
+        this.generateNodesHtml(nodesOutputFile + ".html", ownedNodes);
 
         // Step 3. compose the JS structure for each of the nodes.
         // 1. get a list of the files to import.
@@ -153,15 +140,37 @@ ${nodeHTMLOutut}
 ${NodeGenerator.warning}
 */
 "use strict";
-const NodeManager = require("@theotherwillembotha/node-red-plugincore").NodeManager;
+const { NodeManager } = require("./runtime/NodeManagerRuntime");
 ${importList}
 module.exports = (RED) => {
 let manager = new NodeManager(RED);
 ${moduleExports}
-}        
-        
+}
+
         `);
 
+        // Copy NodeManagerRuntime.js into the plugin's build/runtime/ folder so that
+        // the generated Nodes.js require("./runtime/NodeManagerRuntime") resolves locally
+        // with no dependency on plugincore being installed in the user's environment.
+        const outputDir = path.dirname(nodesOutputFile);
+        const runtimeDestDir = path.join(outputDir, 'runtime');
+        const runtimeDestPath = path.join(runtimeDestDir, 'NodeManagerRuntime.js');
+
+        let runtimeSrcPath: string;
+        try {
+            // Resolves when this is a consumer plugin - plugincore is in node_modules.
+            runtimeSrcPath = require.resolve('@theotherwillembotha/node-red-plugincore/build/runtime/NodeManagerRuntime');
+        } catch {
+            // We ARE plugincore - NodeManagerRuntime.js is compiled alongside us in build/core/.
+            runtimeSrcPath = path.join(__dirname, 'NodeManagerRuntime.js');
+        }
+
+        if (path.resolve(runtimeSrcPath) !== path.resolve(runtimeDestPath)) {
+            fs.mkdirSync(runtimeDestDir, { recursive: true });
+            fs.copyFileSync(runtimeSrcPath, runtimeDestPath);
+        }
+        console.log(`NodeManagerRuntime.js → ${runtimeDestPath}`);
+
         console.log(`Done building ${Object.keys(this._nodes).length} nodes\n${Object.values(this._nodes).map(node => " - " + node.descriptor.id() + "\n").join("")}\n`);
 
         let serviceExports = this._services.map(service => {
@@ -196,29 +205,38 @@ module.exports = function (RED) {
 
             if(addedPlugin && plugin.instantiate && !plugin.instance){
                 plugin.instance = new plugin.class();
-                
+
                 // instantiate the plugin.
                 await plugin.instance.init(RED);
 
+                // Eagerly call onDeploy with any pre-existing saved flows so that
+                // service registries (MetricsService, WebhookServerService, etc.) are
+                // populated before config nodes are constructed during flow startup.
+                // Without this, MetricsConfigNode._metrics is undefined on first boot.
+                const existingFlows = await runtime.flows.getFlows({});
+                const hasExistingFlows = existingFlows && existingFlows.flows && existingFlows.flows.length > 0;
+                if (hasExistingFlows) {
+                    await plugin.instance.onDeploy(existingFlows);
+                }
+
                 // publish an event that it has ben deployed.
                 RED.events.emit("plugin.instantiated", pluginID);
-                                
+
                 pluginList.splice(pluginList.findIndex(current => current.id() === addedPlugin.id()), 1);
 
                 // register a flow deployment listener.
-                let startupDeployment = true;
+                // startupDeployment is only needed for a truly fresh Node-RED with no saved flows.
+                let startupDeployment = !hasExistingFlows;
                 RED.events.on('runtime-event', async (event) => {
-                    // startup deployment.
+                    // startup deployment (fresh Node-RED with no pre-existing flows).
                     if ("runtime-deploy" === event?.id && startupDeployment) {
-                        //console.log("STARTUP DEPLOYMENT");
                         startupDeployment = false;
                         const flows = await runtime.flows.getFlows({});
                         await plugin.instance.onDeploy(flows);
                     }
-                    
+
                     // stopping flows on redeployment.
                     if ("runtime-state" === event?.id && event?.payload?.state === "stop" && event?.payload?.deploy) {
-                        //console.log("REDEPLOY!");
                         const flows = await runtime.flows.getFlows({});
                         await plugin.instance.onDeploy(flows);
                     }
@@ -239,6 +257,97 @@ module.exports = function (RED) {
 `
         fs.writeFileSync(pluginsOutputFile + ".js", output);
         console.log(`Done building ${this._services.length} services\n${this._services.map(service => " - " + service.name() + "\n").join("")}\n`);
+
+        // STEP 4. Generate Plugins.html with deferred client-side definitions for shared nodes.
+        this.generatePluginsHtml(pluginsOutputFile + ".html", sharedNodes);
+    }
+
+    private generateNodesHtml(filePath: string, nodes: {nodeClass: INodeClass, descriptor: NodeDescriptor}[]): void {
+        if (nodes.length === 0) {
+            fs.writeFileSync(filePath, `
+<!--
+${NodeGenerator.warning}
+No owned nodes in this package. Shared nodes are registered via Plugins.html.
+-->
+            `);
+            console.log(`Nodes.html: no owned nodes\n`);
+            return;
+        }
+
+        const seenOnce = new Set<string>();
+        const onceHtmlParts: string[] = [];
+        const nodeParts: string[] = [];
+
+        nodes.forEach(node => {
+            console.log(`Building Nodes.html for: ${node.descriptor.id()}`);
+            const nb = buildNodeBuilder(node.nodeClass);
+
+            nb.buildOnceHtml().forEach(({source, html}) => {
+                if (!seenOnce.has(source)) {
+                    seenOnce.add(source);
+                    onceHtmlParts.push(html);
+                }
+            });
+
+            nodeParts.push([
+                nb.buildStandardType(),
+                nb.buildHtml(),
+                nb.buildDocumentation()
+            ].join('\n\n'));
+        });
+
+        fs.writeFileSync(filePath, `
+<!--
+${NodeGenerator.warning}
+-->
+${onceHtmlParts.join('\n')}
+${nodeParts.join('\n\n')}
+        `);
+        console.log(`Done building Nodes.html (${nodes.length} owned nodes)\n`);
+    }
+
+    private generatePluginsHtml(filePath: string, nodes: {nodeClass: INodeClass, descriptor: NodeDescriptor}[]): void {
+        if (nodes.length === 0) {
+            fs.writeFileSync(filePath, `
+<!--
+${NodeGenerator.warning}
+No shared nodes in this package. All nodes are registered via Nodes.html.
+-->
+            `);
+            console.log(`Plugins.html: no shared nodes\n`);
+            return;
+        }
+
+        const seenOnce = new Set<string>();
+        const onceHtmlParts: string[] = [];
+        const nodePluginParts: string[] = [];
+
+        nodes.forEach(node => {
+            console.log(`Building Plugins.html for: ${node.descriptor.id()}`);
+            const nb = buildNodeBuilder(node.nodeClass);
+
+            nb.buildOnceHtml().forEach(({source, html}) => {
+                if (!seenOnce.has(source)) {
+                    seenOnce.add(source);
+                    onceHtmlParts.push(html);
+                }
+            });
+
+            nodePluginParts.push([
+                nb.buildDeferredType(),
+                nb.buildHtml(),
+                nb.buildDocumentation()
+            ].join('\n\n'));
+        });
+
+        fs.writeFileSync(filePath, `
+<!--
+${NodeGenerator.warning}
+-->
+${onceHtmlParts.join('\n')}
+${nodePluginParts.join('\n\n')}
+        `);
+        console.log(`Done building Plugins.html (${nodes.length} shared nodes)\n`);
     }
 
     private static generateHeader(node:NodeDescriptor){
@@ -265,7 +374,7 @@ class TypeUtility {
     private constructor(){}
 
     private static getPrototypes(t:INamedType):string[] {
-        if(!t.name){
+        if(!t || !t.name){
             return [];
         }
         else{

package/src/core/NodeManagerRuntime.ts

@@ -0,0 +1,179 @@
+/**
+ * NodeManagerRuntime.ts
+ *
+ * STANDALONE - zero imports from the rest of plugincore.
+ *
+ * This file is compiled and copied into every plugin's build output so that
+ * plugins are self-contained and do not require plugincore to be separately
+ * installed in the user's Node-RED environment.
+ *
+ * When multiple plugins are deployed, each ships its own copy of this file.
+ * The first plugin to load registers its NodeManager and nodes; subsequent
+ * copies operate independently on their own node types with no conflict.
+ *
+ * POST_CONSTRUCT_KEY is intentionally a plain string (not a Symbol) so that
+ * the decorators (from plugincore's NodeConstructor, loaded via the plugin's
+ * dependency on plugincore) and this runtime file (a separate module instance)
+ * resolve to the same property key on node instances.
+ */
+
+import type { NodeAPI, NodeAPISettingsWithData } from "node-red";
+
+// ─── API version ────────────────────────────────────────────────────────────
+// Semver of the NodeManager API contract - independent of plugincore's package
+// version. Bump when the contract changes; plugins can read this to warn users
+// that they were built against a different NodeManager version.
+export const NODEMANAGER_API_VERSION = "1.0.0";
+
+// ─── Shared key for post-construct initializer lists ────────────────────────
+// Must be a plain string so it resolves identically across module instances.
+export const POST_CONSTRUCT_KEY = '__plugincore_postConstructInitializers__';
+
+// ─── Minimal types ───────────────────────────────────────────────────────────
+
+export interface BaseNodeConfig {
+    id: string;
+    name: string;
+    type: string;
+}
+
+interface INodeDescriptor {
+    id(): string;
+    tags(): string[];
+}
+
+interface INodeClass {
+    new(node: any, config: any): any;
+    getNodeDescriptor(): INodeDescriptor;
+}
+
+// ─── Post-construct initializer runner ───────────────────────────────────────
+
+export function runPostConstructInitializers(instance: any): void {
+    const initializers: Function[] = instance[POST_CONSTRUCT_KEY];
+    if (!initializers || initializers.length === 0) return;
+
+    const className = instance.constructor.name;
+    initializers.forEach((init, index) => {
+        try {
+            init(instance);
+        } catch (error) {
+            console.error(
+                `Post-construct initialization failed:\n` +
+                `  Class: ${className}\n` +
+                `  Initializer: ${index + 1}/${initializers.length}\n` +
+                `  Error: ${error instanceof Error ? error.message : String(error)}`
+            );
+            throw error;
+        }
+    });
+
+    delete instance[POST_CONSTRUCT_KEY];
+}
+
+// ─── NodeManager ─────────────────────────────────────────────────────────────
+// RED is stored on `global` rather than as a static class field so that all
+// module instances of NodeManagerRuntime (the local copy bundled into Nodes.js
+// and the copy bundled via plugincore's NodeConstructor) share the same value.
+// Without this, esbuild's two separate inline copies would have independent
+// static fields and the one used by decorators would never see RED being set.
+const _GLOBAL_RED_KEY = '__plugincore_NodeManager_RED__';
+
+// ─── Global node-type registration guard ─────────────────────────────────────
+// When multiple self-contained plugins are installed they each bundle plugincore
+// inline and each try to call RED.nodes.registerType for the same shared
+// infrastructure node types (ConsoleLoggerConfigNode, RestLoggerConfigNode, etc.).
+// Node-RED rejects duplicate registrations with a warning and the second
+// plugin's Nodes.js fails to load. This global set tracks which types have
+// already been registered so subsequent plugins silently skip them.
+const _GLOBAL_REGISTERED_NODES_KEY = '__plugincore_registered_nodes__';
+
+function getRegisteredNodes(): Set<string> {
+    if (!(global as any)[_GLOBAL_REGISTERED_NODES_KEY]) {
+        (global as any)[_GLOBAL_REGISTERED_NODES_KEY] = new Set<string>();
+    }
+    return (global as any)[_GLOBAL_REGISTERED_NODES_KEY];
+}
+
+export class NodeManager {
+
+    // nodeTypeService is resolved dynamically via RED.plugins - no static import needed.
+    private nodeTypeService: any;
+    private typeBacklog: INodeClass[] = [];
+
+    public constructor(RED: NodeAPI<NodeAPISettingsWithData>) {
+        (global as any)[_GLOBAL_RED_KEY] = RED;
+
+        const nodeTypeServiceId = "@theotherwillembotha/nodetypeservice";
+
+        const nodeTypeServiceListener = (pluginID: string) => {
+            if (pluginID === nodeTypeServiceId) {
+                RED.events.off('plugin.instantiated', nodeTypeServiceListener);
+                this.nodeTypeService = (RED.plugins.get(nodeTypeServiceId) as any).instance;
+
+                for (const nodeType of this.typeBacklog) {
+                    for (const tag of nodeType.getNodeDescriptor().tags()) {
+                        this.nodeTypeService.registerNodeType(tag, nodeType);
+                    }
+                }
+                this.typeBacklog = [];
+            }
+        };
+
+        this.nodeTypeService = (RED.plugins.get(nodeTypeServiceId) as any)?.instance;
+        if (!this.nodeTypeService) {
+            RED.events.on('plugin.instantiated', nodeTypeServiceListener);
+        }
+    }
+
+    public static get RED(): NodeAPI<NodeAPISettingsWithData> {
+        return (global as any)[_GLOBAL_RED_KEY];
+    }
+
+    public registerNodeType(typeName: string, type: INodeClass): NodeManager {
+        if (!type) {
+            console.error(
+                `[NodeManager v${NODEMANAGER_API_VERSION}] Type "${typeName}" is undefined. ` +
+                `Ensure it is exported and included in GenerateNodes.`
+            );
+            return this;
+        }
+
+        const registeredNodes = getRegisteredNodes();
+        if (registeredNodes.has(typeName)) {
+            // Already registered by another plugin - skip to avoid Node-RED duplicate-registration error.
+            return this;
+        }
+        registeredNodes.add(typeName);
+
+        const nodeConstructor = function(this: any, config: any) {
+            try {
+                NodeManager.RED.nodes.createNode(this, config);
+                const node = new (type as any)(this, config);
+                runPostConstructInitializers(node);
+                if (node.onInit) {
+                    node.onInit();
+                }
+            } catch (error) {
+                console.error(`[NodeManager v${NODEMANAGER_API_VERSION}] Failed to construct node "${typeName}":`, error);
+            }
+        };
+
+        try {
+            NodeManager.RED.nodes.registerType(typeName, nodeConstructor, { settings: {} });
+
+            const nodeDescription = type.getNodeDescriptor();
+            if (this.nodeTypeService) {
+                for (const tag of nodeDescription.tags()) {
+                    this.nodeTypeService.registerNodeType(tag, type);
+                }
+            } else {
+                this.typeBacklog.push(type);
+            }
+        } catch (error) {
+            console.error(`[NodeManager v${NODEMANAGER_API_VERSION}] Failed to register node type "${typeName}":`, error);
+        }
+
+        return this;
+    }
+}

package/src/core/logger/service/LoggerService.ts

@@ -1,15 +1,35 @@
 
-import {BaseService, ServiceDescriptor, ConfigNodeConfig, ConfigNode } from "../../NodeConstructor";
+import * as os from 'os';
+import {BaseService, ConfigNodeConfig, ConfigNode } from "../../NodeConstructor";
+import { ServiceDescription } from "../../tagging/ServiceDescriptionDecorator";
 import { NodeAPI, NodeAPISettingsWithData, Node } from "node-red";
-import Handlebars from "handlebars";
 import { LoggerTemplate, LoggerTemplateConfig } from "../template/LoggerTemplate";
-var network = require('network');
 
-// helper for serializing json objects inside handlebars tags.
-// you can then convert it like this: {{{json myobject}}}
-Handlebars.registerHelper('json', function(context) {
-    return JSON.stringify(context);
-});
+// Build-time / optional runtime deps - lazy so they are never required at bundle load time.
+function getHandlebars(): any { return require('handlebars'); }
+
+function getLocalIpAddress(): string {
+    const interfaces = os.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+        for (const iface of interfaces[name] ?? []) {
+            if (iface.family === 'IPv4' && !iface.internal) {
+                return iface.address;
+            }
+        }
+    }
+    return '127.0.0.1';
+}
+
+let _helpersRegistered = false;
+function ensureHelpersRegistered(): void {
+    if (_helpersRegistered) return;
+    _helpersRegistered = true;
+    // helper for serializing json objects inside handlebars tags.
+    // you can then convert it like this: {{{json myobject}}}
+    getHandlebars().registerHelper('json', function(context: any) {
+        return JSON.stringify(context);
+    });
+}
 
 export enum Level{
     DEBUG = "DEBUG",
@@ -40,12 +60,13 @@ export type TagMap = {
 
 export abstract class Log  {
     private _config: LoggerTemplateConfig;
-    private template: HandlebarsTemplateDelegate<any>;
+    private _templateStr: string;
+    private _compiledTemplate: any = null;
     private tags:TagMap;
 
     protected constructor(config:LoggerTemplateConfig){
         this._config = config;
-        this.template = Handlebars.compile(config.template);
+        this._templateStr = config.template;
         this.tags = {
             id: config.id,
             node: config.name,
@@ -55,6 +76,14 @@ export abstract class Log  {
         }
     }
 
+    private getTemplate(): any {
+        if (!this._compiledTemplate) {
+            ensureHelpersRegistered();
+            this._compiledTemplate = getHandlebars().compile(this._templateStr);
+        }
+        return this._compiledTemplate;
+    }
+
     protected config():LoggerTemplateConfig{
         return this._config;
     }
@@ -62,7 +91,7 @@ export abstract class Log  {
     public log(payload:{[key:string]:any}|string):void{
         try{
             // step 1. serialize the payload using the template engine.
-            let message = (payload instanceof String) ? payload as string : this.template({msg:payload});
+            let message = (payload instanceof String) ? payload as string : this.getTemplate()({msg:payload});
 
             // step 2. write to the log appender.
             this.writeToLog(this.config().level, message, this.tags);
@@ -71,7 +100,7 @@ export abstract class Log  {
             console.log(e);
         }
     }
-    
+
     protected abstract writeToLog(level:string, message:string, tags:{[key:string]:string|boolean|number}):void;
 }
 
@@ -110,9 +139,22 @@ export abstract class AbstractLogger<BaseLoggerConfig>{
     protected abstract createLogger(config: LoggerTemplateConfig):Log;
 }
 
+@ServiceDescription({
+    id: "@theotherwillembotha/loggerservice",
+    sourceFile: "@theotherwillembotha/node-red-plugincore",
+    dependencies: [LoggerTemplate]
+})
 export class LoggerService extends BaseService {
 
-    public static instanceID:string;
+    // Backed by a global so the value is shared across separately-bundled copies
+    // of plugincore (Nodes.js and Plugins.js each inline their own copy).
+    public static get instanceID(): string {
+        return (global as any).__plugincore_instance_id__ ?? '';
+    }
+    public static set instanceID(value: string) {
+        (global as any).__plugincore_instance_id__ = value;
+    }
+
     private red!: NodeAPI<NodeAPISettingsWithData>;
 
     constructor(){
@@ -121,26 +163,11 @@ export class LoggerService extends BaseService {
 
     public init(red: NodeAPI<NodeAPISettingsWithData>): void | Promise<void> {
         this.red = red;
-
-        return new Promise<void>((resolve) => {
-            network.get_active_interface((err:any, obj:any) => {
-                LoggerService.instanceID = obj.ip_address;
-            });
-        });
+        LoggerService.instanceID = getLocalIpAddress();
     }
 
     public deinit(red: NodeAPI<NodeAPISettingsWithData>): void | Promise<void> {}
 
-    static override getServiceDescriptor():ServiceDescriptor {
-        return new ServiceDescriptor(
-            "@theotherwillembotha/loggerservice",
-            "LoggerService",
-            "services-plugin",
-            "@theotherwillembotha/node-red-plugincore",
-            LoggerService,
-            [LoggerTemplate]
-        );
-    }
 }
 
 export type LoggerConfigNodeConfig = ConfigNodeConfig & BaseLoggerConfig & {}
@@ -160,10 +187,11 @@ export abstract class LoggerConfigNode<CNC extends LoggerConfigNodeConfig, Logge
 
 export class DoNothingAppender extends Log{
 
-    private static instance:DoNothingAppender = new DoNothingAppender();
+    private static _instance: DoNothingAppender | null = null;
 
-    static get(): any {
-      return DoNothingAppender.instance;
+    static get(): DoNothingAppender {
+        if (!DoNothingAppender._instance) DoNothingAppender._instance = new DoNothingAppender();
+        return DoNothingAppender._instance;
     }
 
     private constructor(){

package/src/core/logger/template/LoggerTemplate.html

@@ -108,13 +108,13 @@
 </script>
 
 <script type="text/javascript" template-section="onIncludeEditPrepare">
-    let node = this;
-
     // controls.
     let logEnabled = $("#{{defaults.logEnabled}}");
     let logTemplateEnabled = $("#{{defaults.logTemplateOverrideEnabled}}");
     let logTemplateEnabledSection = $("#section_logTemplateOverrideEnabled");
     let logEnabledSection = $("#section_logEnabled");
+    let loggerSection = $("#section_loggerconfig");
+    loggerSection.hide();
 
     // functions.
     let getLoggerTypes = async function(){
@@ -262,10 +262,15 @@
         }
     });
     
-    // lastly, make sure that we set the correct value on the logger selector.
-    updateLoggerSelectorList().then(() => {
-        loggerSelector.val(node.logger);
-        loggerSelector.trigger('change');
+    // Show the logger section only if at least one logger type is registered.
+    // If nodered_logging (or any other logger provider) is not installed, the section stays hidden.
+    getLoggerTypes().then(loggerTypes => {
+        if (loggerTypes.length === 0) return;
+        loggerSection.show();
+        updateLoggerSelectorList().then(() => {
+            loggerSelector.val(node.logger);
+            loggerSelector.trigger('change');
+        });
     });
 
 </script>