@theotherwillembotha/node-red-plugincore 0.0.50

package/build/core/NodeConstructor.js

@@ -0,0 +1,679 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildNode = exports.NodeBuilder = exports.BaseService = exports.NodeManager = exports.Template = exports.ServiceDescriptor = exports.TemplateDescriptor = exports.NodeDescriptor = exports.ConfigNode = exports.BaseNode = void 0;
+exports.createPostConstructDecorator = createPostConstructDecorator;
+require("reflect-metadata");
+const jsdom_1 = __importDefault(require("jsdom"));
+const fs_1 = __importDefault(require("fs"));
+const js_beautify_1 = __importDefault(require("js-beautify"));
+const markdown_it_1 = __importDefault(require("markdown-it"));
+const handlebars_1 = __importDefault(require("handlebars"));
+class BaseNode {
+    node() { return this._node; }
+    config() { return this._config; }
+    flow() { return this._flow; }
+    // THIS value is imported from NodeRed Node itself.
+    id() { return this.config().id; }
+    ;
+    type() { return this.config().type; }
+    ;
+    name() { return this.config().name; }
+    ;
+    constructor(node, config) {
+        this._node = node;
+        this._config = config;
+        this._flow = (this._node._flow?.flow).label;
+        // inject a reverse lookup so the NodeRedNode can refer back to the waos node:
+        this._node.node = () => { return this; };
+    }
+    // this function can be overwritten to be triggered after the constructor and
+    // decorators have been called.
+    onInit() { }
+    // note: this function should be implemented by every concrete implementation of the BaseNode class.
+    static getNodeDescriptor() {
+        throw new Error("getNodeDescriptor not implemented.");
+    }
+}
+exports.BaseNode = BaseNode;
+class ConfigNode extends BaseNode {
+    constructor(node, config) {
+        super(node, config);
+    }
+    static getNodeDescriptor() {
+        throw new Error("getNodeDescriptor not implemented.");
+    }
+}
+exports.ConfigNode = ConfigNode;
+class NodeDescriptor {
+    constructor(group, name, sourceFile, pkg) {
+        this._dependencies = [];
+        this._templates = [];
+        this._tags = [];
+        this._group = group;
+        this._name = name;
+        this._sourceFile = sourceFile;
+        this._package = pkg;
+    }
+    // DEPRECATED
+    addDependency(dependency) {
+        this._dependencies.push(dependency);
+        return this;
+    }
+    // DEPRECATED
+    addTag(tag) {
+        this._tags.push(tag);
+        return this;
+    }
+    // DEPRECATED
+    addTemplate(template, config) {
+        // TODO: we can only add every template once.
+        this._dependencies.push(template);
+        this._templates.push({ template: template, config: config });
+        return this;
+    }
+    group() { return this._group; }
+    name() { return this._name; }
+    sourceFile() { return this._sourceFile; }
+    package() { return this._package; }
+    dependencies() { return this._dependencies; }
+    templates() { return this._templates; }
+    tags() { return this._tags; }
+}
+exports.NodeDescriptor = NodeDescriptor;
+class TemplateDescriptor {
+    constructor(name, clazz, templateFile, dependencies) {
+        this._name = name;
+        this._clazz = clazz;
+        this._templateFile = templateFile;
+        this._dependencies = dependencies;
+    }
+    name() {
+        return this._name;
+    }
+    clazz() {
+        return this._clazz;
+    }
+    dependencies() {
+        return this._dependencies;
+    }
+    templateFile() {
+        return this._templateFile;
+    }
+}
+exports.TemplateDescriptor = TemplateDescriptor;
+class ServiceDescriptor {
+    constructor(id, name, type, sourceFile, clazz, dependencies) {
+        this._id = id;
+        this._name = name;
+        this._type = type;
+        this._sourceFile = sourceFile;
+        this._clazz = clazz;
+        this._dependencies = dependencies ? dependencies : [];
+    }
+    id() { return this._id; }
+    ;
+    name() { return this._name; }
+    ;
+    type() { return this._type; }
+    ;
+    sourceFile() { return this._sourceFile; }
+    ;
+    clazz() { return this._clazz; }
+    ;
+    dependencies() { return this._dependencies; }
+    ;
+}
+exports.ServiceDescriptor = ServiceDescriptor;
+class Template {
+    static getTemplateDescriptor() {
+        throw new Error("getTemplateDescriptor not implemented for " + this.name);
+    }
+}
+exports.Template = Template;
+const POST_CONSTRUCT_KEY = Symbol('postConstructInitializers');
+// Builder class for post-construct decorators
+class PostConstructDecoratorBuilder {
+    constructor(decoratorName) {
+        this.decoratorName = decoratorName;
+    }
+    // Set default config for when brackets are omitted
+    withDefaultConfig(config) {
+        this.defaultConfig = config;
+        return this;
+    }
+    // Method to set initialization logic
+    withInitLogic(initLogic) {
+        this.initLogic = initLogic;
+        return this;
+    }
+    // Method to set custom validation logic
+    withValidator(validator) {
+        this.validator = validator;
+        return this;
+    }
+    // Build the actual decorator factory (returns a function that takes metadata and returns a decorator)
+    build() {
+        const decoratorName = this.decoratorName;
+        const initLogic = this.initLogic;
+        const validator = this.validator;
+        const defaultConfig = this.defaultConfig;
+        // The actual decorator implementation
+        const decoratorImpl = (config) => {
+            return (target, propertyKey, descriptor) => {
+                try {
+                    const className = target.constructor.name;
+                    const originalMethod = descriptor.value;
+                    if (typeof originalMethod !== 'function') {
+                        throw new Error(`@${decoratorName} decorator error:\n` +
+                            `  Class: ${className}\n` +
+                            `  Property: ${propertyKey}\n` +
+                            `  Issue: Decorator can only be applied to methods.`);
+                    }
+                    const returnType = Reflect.getMetadata?.('design:returntype', target, propertyKey);
+                    if (returnType && returnType !== Promise && returnType !== void 0 && returnType !== undefined) {
+                        console.warn(`@${decoratorName} decorator warning:\n` +
+                            `  Class: ${className}\n` +
+                            `  Method: ${propertyKey}\n` +
+                            `  Issue: Method should return void or Promise<void>, but appears to return ${returnType.name}.`);
+                    }
+                    if (validator) {
+                        try {
+                            validator(target, propertyKey, descriptor);
+                        }
+                        catch (error) {
+                            throw new Error(`@${decoratorName} decorator validation error:\n` +
+                                `  Class: ${className}\n` +
+                                `  Method: ${propertyKey}\n` +
+                                `  Issue: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                    const wrappedMethod = async function (...args) {
+                        const result = await originalMethod.apply(this, args);
+                        if (result !== undefined && result !== null) {
+                            console.warn(`@${decoratorName} runtime warning:\n` +
+                                `  Class: ${className}\n` +
+                                `  Method: ${propertyKey}\n` +
+                                `  Issue: Method returned a value (${typeof result}) but should return void or Promise<void>.`);
+                        }
+                    };
+                    if (!target[POST_CONSTRUCT_KEY]) {
+                        target[POST_CONSTRUCT_KEY] = [];
+                    }
+                    target[POST_CONSTRUCT_KEY].push((instance) => {
+                        if (initLogic) {
+                            try {
+                                initLogic(instance, propertyKey, config);
+                            }
+                            catch (error) {
+                                throw new Error(`@${decoratorName} initialization error:\n` +
+                                    `  Class: ${className}\n` +
+                                    `  Method: ${propertyKey}\n` +
+                                    `  Issue: ${error instanceof Error ? error.message : String(error)}`);
+                            }
+                        }
+                    });
+                    descriptor.value = wrappedMethod;
+                    return descriptor;
+                }
+                catch (e) {
+                    console.error("failed creating DecoratorImplementation:", "target:", target, "propertyKey:", propertyKey, "descriptor:", descriptor, "error:", e);
+                    throw e;
+                }
+            };
+        };
+        // Return overloaded decorator that works with or without ()
+        const overloadedDecorator = function (targetOrConfig, propertyKey, descriptor) {
+            // Check if called without brackets (directly on method)
+            if (propertyKey !== undefined && descriptor !== undefined) {
+                // Called as @decorator (without brackets)
+                return decoratorImpl(defaultConfig)(targetOrConfig, propertyKey, descriptor);
+            }
+            else {
+                // Called as @decorator() or @decorator({...})
+                return decoratorImpl(targetOrConfig);
+            }
+        };
+        return overloadedDecorator;
+    }
+}
+// Factory function to create decorator builders
+function createPostConstructDecorator(decoratorName) {
+    return new PostConstructDecoratorBuilder(decoratorName);
+}
+// Single function to run all post-construct initializers
+let runPostConstructInitializers = function (instance) {
+    const initializers = instance[POST_CONSTRUCT_KEY];
+    if (initializers && initializers.length > 0) {
+        const className = instance.constructor.name;
+        //console.log(`Running ${initializers.length} post-construct initializers for ${className}`);
+        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;
+            }
+        });
+        // Clear the initializers after running
+        delete instance[POST_CONSTRUCT_KEY];
+    }
+};
+// ************************************************
+class NodeManager {
+    constructor(RED) {
+        this.typeBacklog = [];
+        NodeManager._RED = RED;
+        let nodeTypeServiceListener = async (pluginID) => {
+            if (pluginID === "@theotherwillembotha/nodetypeservice") {
+                // disable the listener- the plugin has been installed.
+                RED.events.off('plugin.instantiated', nodeTypeServiceListener);
+                // get a handle on the NodeTypeService
+                let plugin = RED.plugins.get("@theotherwillembotha/nodetypeservice");
+                this.nodeTypeService = RED.plugins.get("@theotherwillembotha/nodetypeservice").instance;
+                // process the backlog.
+                for (let nodeType of this.typeBacklog) {
+                    for (let tag of nodeType.getNodeDescriptor().tags()) {
+                        this.nodeTypeService.registerNodeType(tag, nodeType);
+                    }
+                }
+            }
+        };
+        // check if the reverserproxyttypesewrvice is installed yet.
+        this.nodeTypeService = RED.plugins.get("@theotherwillembotha/nodetypeservice").instance;
+        if (this.nodeTypeService) {
+            console.log("NodeTypeService installed!");
+        }
+        else {
+            // Register a listener to trigger when the RegerseProxyTypService gets installed.
+            console.log("nodetypeservice not installed yet. waiting for it to be installed");
+            RED.events.on('plugin.instantiated', nodeTypeServiceListener);
+        }
+    }
+    static get RED() {
+        return NodeManager._RED;
+    }
+    registerService(type) {
+        let servicePlugin = NodeManager.RED.plugins.get(NodeManager.PLUGINID);
+        if (servicePlugin) {
+            servicePlugin.instance.install(NodeManager.RED, type);
+        }
+        else {
+            let serviceName = `${type.getServiceDescriptor().sourceFile()}.${type.getServiceDescriptor().name()}`;
+            console.log(`ERROR: plugin ${NodeManager.PLUGINID} does not seem to be loaded. Cannot start service: ${serviceName}`);
+        }
+        return this;
+    }
+    registerNodeType(typeName, type) {
+        if (!type) {
+            console.error(`Type "${typeName}" has no associated type. Make sure that it was exported and included in the index.js file!`);
+        }
+        let nodeConstructor = function (config) {
+            console.log("constructing node", typeName);
+            try {
+                // instantiate the node.
+                NodeManager.RED.nodes.createNode(this, config);
+                // assign an instance of it to the config.
+                //(config as any).__node = this;
+                // instatiate the actual node.
+                let node = new type(this, config);
+                //this.__node = node;
+                // run the constructor initializers.
+                runPostConstructInitializers(node);
+                // after the node has been instantiated, attempt to invole the onInit method.
+                if (node.onInit) {
+                    node.onInit();
+                }
+            }
+            catch (error) {
+                console.log(error);
+                console.log("typeName:", typeName);
+                console.log("type:", type);
+                console.log("config:", config);
+            }
+        };
+        try {
+            console.log("registering node " + typeName);
+            NodeManager.RED.nodes.registerType(typeName, nodeConstructor, { settings: {} });
+            let nodeDescription = type.getNodeDescriptor();
+            // registger the node tags.
+            if (this.nodeTypeService) {
+                for (let tag of nodeDescription.tags()) {
+                    this.nodeTypeService.registerNodeType(tag, type);
+                }
+            }
+            else {
+                this.typeBacklog.push(type);
+            }
+            console.log("registered node " + typeName);
+        }
+        catch (error) {
+            console.error("registering node: " + typeName + " failed", error);
+        }
+        return this;
+    }
+}
+exports.NodeManager = NodeManager;
+NodeManager.PLUGINID = "node-red-contrib-theotherwillembotha/services-plugin";
+class BaseService {
+    constructor(name) {
+        this._name = name;
+    }
+    name() {
+        return this._name;
+    }
+    onDeploy(flowDeployment) {
+        return Promise.resolve();
+    }
+    static getServiceDescriptor() {
+        throw new Error("getServiceDescriptor not implemented.");
+    }
+}
+exports.BaseService = BaseService;
+const { JSDOM } = jsdom_1.default;
+const md = (0, markdown_it_1.default)({
+    html: true,
+    linkify: true,
+    typographer: true
+});
+// Custom renderer for headings
+md.renderer.rules.heading_open = function (tokens, idx, options, env, self) {
+    const token = tokens[idx];
+    const level = token.tag.substring(1); // 'h1', 'h2', etc. -> '1', '2'
+    return `<h${level} class="custom-heading">`;
+};
+md.renderer.rules.heading_close = function (tokens, idx, options, env, self) {
+    const token = tokens[idx];
+    const level = token.tag.substring(1);
+    return `</h${level}>`;
+};
+let beautifyOptions = {
+    "indent_size": 4,
+    "preserve-newlines": false,
+    "html": {
+        "end_with_newline": true,
+        "js": {
+            "indent_size": 2,
+            "preserve-newlines": false
+        },
+        "css": {
+            "indent_size": 2,
+        }
+    },
+    "css": {
+        "indent_size": 1
+    },
+    "js": {
+        "preserve-newlines": false
+    },
+};
+class NodeBuilder {
+    constructor(name, category) {
+        this._defaults = {};
+        this._outputs = [];
+        this._onIncludeOnce = [];
+        this._onIncludeEditPrepare = [];
+        this._onIncludeEditSave = [];
+        this._onIncludeEditCancel = [];
+        this._onIncludeEditDelete = [];
+        this._onIncludeEditForm = [];
+        this._onIncludeDocumentation = [];
+        this._name = name;
+        this._category = category;
+    }
+    addDefault(name, template) {
+        // if the template type ends with squeare brackets, its an array type.
+        if (template.type && template.type.endsWith("[]")) {
+            template.maxInstances = template.maxInstances ? template.maxInstances : 10;
+            this._defaults[name] = { type: template.type, value: "", required: true, maxInstances: template.maxInstances };
+            for (let i = 0; i < template.maxInstances; i++) {
+                this._defaults["_" + name + "_" + i] = { value: "", required: false };
+            }
+        }
+        else {
+            this._defaults[name] = template;
+        }
+        return this;
+    }
+    setIcon(icon) {
+        this._icon = icon;
+        return this;
+    }
+    setColor(color) {
+        this._color = color;
+        return this;
+    }
+    setLabel(label) {
+        this._label = label.toString();
+        return this;
+    }
+    setPaletteLabel(paletteLabel) {
+        this._paletteLabel = paletteLabel;
+        return this;
+    }
+    setLabelStyle(labelStyle) {
+        this._labelStyle = labelStyle;
+        return this;
+    }
+    setInput(input) {
+        this._inputs = input;
+        return this;
+    }
+    addOutputs(...outputs) {
+        outputs.forEach(output => this._outputs.push(output));
+        return this;
+    }
+    addTemplate(template) {
+        let templateDescriptor = template.template.getTemplateDescriptor();
+        // load the html source file
+        let uiDom = new JSDOM(fs_1.default.readFileSync(templateDescriptor.templateFile()));
+        // apply the onCompose section if available.
+        let onCompose = uiDom.window.document.querySelector("script[template-section='onCompose']")?.innerHTML;
+        if (onCompose) {
+            evalInContext({ node: this }, onCompose.toString());
+        }
+        // load the other sections and add them as needed.
+        let sections = ['IncludeOnce', 'IncludeEditPrepare', 'IncludeEditSave', 'IncludeEditCancel', 'IncludeEditDelete', 'IncludeEditForm', 'IncludeDocumentation'];
+        Object.values(sections).forEach(section => {
+            let sectionData = uiDom.window.document.querySelector(`[template-section='on${section}']`)?.innerHTML;
+            if (sectionData) {
+                this[`add${section}`](templateDescriptor.name(), sectionData);
+            }
+        });
+        return this;
+    }
+    addIncludeOnce(source, script) {
+        this._onIncludeOnce.push({ source: source, script: script });
+        return this;
+    }
+    addIncludeEditPrepare(source, script) {
+        this._onIncludeEditPrepare.push({ source: source, script: script });
+        return this;
+    }
+    addIncludeEditSave(source, script) {
+        this._onIncludeEditSave.push({ source: source, script: script });
+        return this;
+    }
+    addIncludeEditCancel(source, script) {
+        this._onIncludeEditCancel.push({ source: source, script: script });
+        return this;
+    }
+    addIncludeEditDelete(source, script) {
+        this._onIncludeEditDelete.push({ source: source, script: script });
+        return this;
+    }
+    addIncludeEditForm(source, script) {
+        this._onIncludeEditForm.push({ source: source, script: script });
+        return this;
+    }
+    addIncludeDocumentation(source, script) {
+        this._onIncludeDocumentation.push({ source: source, script: script });
+        return this;
+    }
+    serializeProperty(value) {
+        switch (typeof value) {
+            case "boolean": {
+                return "" + value;
+            }
+            case "number": {
+                return "" + value;
+            }
+            case "string": {
+                return `'${value}'`;
+            }
+            case "object": {
+                if (Array.isArray(value)) {
+                    return `[${value.map(t => this.serializeProperty(t)).join(", ")}]`;
+                }
+            }
+        }
+        throw new Error(`no serializeProperty handler for ${typeof value}, ${value}`);
+    }
+    serializeHTML(source, script) {
+        let context = {
+            defaults: (this._category === "config")
+                ? Object.fromEntries(Object.keys(this._defaults).map(k => [k, `node-config-input-${k}`]))
+                : Object.fromEntries(Object.keys(this._defaults).map(k => [k, `node-input-${k}`]))
+        };
+        return `<!-- ${source} -->
+        ${handlebars_1.default.compile(script)(context)}
+        `;
+    }
+    serializeJavaScript(source, script) {
+        let context = {
+            defaults: (this._category === "config")
+                ? Object.fromEntries(Object.keys(this._defaults).map(k => [k, `node-config-input-${k}`]))
+                : Object.fromEntries(Object.keys(this._defaults).map(k => [k, `node-input-${k}`]))
+        };
+        let serialized = handlebars_1.default.compile(script)(context).trim();
+        if (!serialized.startsWith("{") && !serialized.endsWith("}")) {
+            serialized = "{\n" + serialized + "\n}";
+        }
+        return `// **** ${source} **** //
+        ${serialized}
+        `;
+    }
+    serializeFormEntry(source, script) {
+        let context = {
+            defaults: (this._category === "config")
+                ? Object.fromEntries(Object.keys(this._defaults).map(k => [k, `node-config-input-${k}`]))
+                : Object.fromEntries(Object.keys(this._defaults).map(k => [k, `node-input-${k}`]))
+        };
+        return `
+            <div id='section_${source}'>${handlebars_1.default.compile(script)(context)}
+            </div>
+        `;
+    }
+    serializeDefault(name, value) {
+        return `${name}: { ${Object.entries(value).map(([k, v]) => `${k}:${this.serializeProperty(v)}`).join(", ")} },`;
+    }
+    serializeDocumentationEntry(source, script) {
+        return script;
+    }
+    buildType() {
+        // compose the shaddow defaults if need be.
+        let shaddowDefaults = Object.entries(this._defaults).filter(([name, template]) => template.type && template.type.endsWith("[]"));
+        if (shaddowDefaults.length > 0) {
+            this.addIncludeEditSave(this._name + "_shaddowDefaults", `{ let node = this; ` +
+                shaddowDefaults
+                    .map(([name, template]) => `
+                    for(let i = 0; i < ${template.maxInstances}; i++){
+                        node["_${name}_" + i] = (node.${name}[i] || {}).proxy || "";
+                    }`)
+                    .join("\n\n") +
+                `}`);
+        }
+        return js_beautify_1.default.html_beautify(`
+        ${this._onIncludeOnce.map(entry => this.serializeHTML(entry.source, entry.script)).join("")}
+        <script type="text/javascript">
+            RED.nodes.registerType('${this._name}',{      
+                category: '${this._category}',
+                ${(this._category !== "config" && this._icon) ? `icon: '${this._icon}',` : ""}
+                ${(this._category !== "config" && this._color) ? `color: '${this._color}',` : ""}
+                ${(this._category !== "config" && this._labelStyle) ? `labelStyle: '${this._labelStyle}',` : ""}
+                ${(this._label) ? `label: ${this._label},` : ""}
+                ${this._paletteLabel ? `paletteLabel: '${this._paletteLabel}',` : ""}
+                ${(this._category !== "config") ? `inputs:${this._inputs ? "1" : "0"},` : ""}
+                ${(this._category !== "config") ? `inputLabels:(i) => '${this._inputs}',` : ""}
+                ${(this._category !== "config") ? `outputs:${this._outputs.length},` : ""}
+                ${(this._category !== "config") ? `outputLabels:(i) => ${this.serializeProperty(this._outputs)}[i],` : ""}
+                defaults: {
+                    ${Object.entries(this._defaults).map(([key, value]) => this.serializeDefault(key, value)).join("\n")}
+                },
+                oneditprepare: function() {
+                    ${this._onIncludeEditPrepare.map(entry => this.serializeJavaScript(entry.source, entry.script)).join("")}
+                },
+                oneditsave: function() {
+                    ${this._onIncludeEditSave.map(entry => this.serializeJavaScript(entry.source, entry.script)).join("")}
+                },
+                oneditcancel: function() {
+                    ${this._onIncludeEditCancel.map(entry => this.serializeJavaScript(entry.source, entry.script)).join("")}
+                },
+                oneditdelete: function() {
+                    ${this._onIncludeEditDelete.map(entry => this.serializeJavaScript(entry.source, entry.script)).join("")}
+                },
+            });
+        </script>`, beautifyOptions);
+    }
+    ;
+    buildHtml() {
+        return js_beautify_1.default.html_beautify(`
+        <script type="text/html" data-template-name='${this._name}'>
+            ${this._onIncludeEditForm.map(entry => this.serializeFormEntry(entry.source, entry.script)).join("")}
+        </script>
+        `);
+    }
+    buildDocumentation() {
+        return [
+            `<script type="text/markdown" data-help-name='${this._name}'>`,
+            this._onIncludeDocumentation.map(entry => this.serializeDocumentationEntry(entry.source, entry.script)).join("").trim(),
+            `</script>`
+        ].join("\n");
+    }
+    ;
+}
+exports.NodeBuilder = NodeBuilder;
+;
+let evalInContext = (context, js) => {
+    const contextKeys = Object.keys(context);
+    const contextValues = Object.values(context);
+    // For scripts, we don't wrap in return() - just execute the code directly
+    try {
+        const func = new Function(...contextKeys, js);
+        return func(...contextValues);
+    }
+    catch (error) {
+        console.log("Error while evaluating onCompose Script for ", context, error);
+        throw error;
+    }
+};
+let buildNode = function (node) {
+    // get the node descriptor and create the builder.
+    let nodeDescriptor = node.getNodeDescriptor();
+    let nodeBuilder = new NodeBuilder(nodeDescriptor.name(), nodeDescriptor.group());
+    // load the html source file
+    let uiDom = new JSDOM(fs_1.default.readFileSync(nodeDescriptor.sourceFile()));
+    // apply the onCompose section if available.
+    let onCompose = uiDom.window.document.querySelector("script[template-section='onCompose']")?.innerHTML;
+    if (onCompose) {
+        evalInContext({ node: nodeBuilder }, onCompose.toString());
+    }
+    // load the other sections and add them as needed.
+    let sections = ['IncludeOnce', 'IncludeEditPrepare', 'IncludeEditSave', 'IncludeEditCancel', 'IncludeEditDelete', 'IncludeEditForm', 'IncludeDocumentation'];
+    Object.values(sections).forEach(section => {
+        let sectionData = uiDom.window.document.querySelector(`[template-section='on${section}']`)?.innerHTML;
+        if (sectionData) {
+            nodeBuilder[`add${section}`](nodeDescriptor.name(), sectionData);
+        }
+    });
+    // add some of the dependencies here.
+    nodeDescriptor.templates().forEach(template => nodeBuilder.addTemplate(template));
+    return [nodeBuilder.buildType(), nodeBuilder.buildHtml(), nodeBuilder.buildDocumentation()].join("\n\n");
+};
+exports.buildNode = buildNode;