node-red/packages/node_modules/@node-red/nodes/core/function/10-function.html

<script type="text/html" data-template-name="function">
    <div class="form-row">
        <label for="node-input-name"><i class="fa fa-tag"></i> <span data-i18n="common.label.name"></span></label>
        <div style="display: inline-block; width: calc(100% - 105px)"><input type="text" id="node-input-name" data-i18n="[placeholder]common.label.name"></div>
    </div>

    <div class="form-row">
        <ul style="min-width: 600px; margin-bottom: 20px;" id="func-tabs"></ul>
    </div>

    <div id="func-tabs-content" style="min-height: calc(100% - 95px);">

        <div id="func-tab-init" style="display:none">
            <div class="form-row" style="margin-bottom: 0px;">
                <input type="hidden" id="node-input-initialize" autofocus="autofocus">
            </div>

            <div class="form-row node-text-editor-row" style="position:relative">
                <div style="position: absolute; right:0; bottom: calc(100% + 3px);"><button id="node-init-expand-js" class="red-ui-button red-ui-button-small"><i class="fa fa-expand"></i></button></div>
                <div style="height: 250px; min-height:150px; margin-top: 30px;" class="node-text-editor" id="node-input-init-editor" ></div>
            </div>
        </div>

        <div id="func-tab-body" style="display:none">
            <div class="form-row" style="margin-bottom: 0px;">
                <input type="hidden" id="node-input-func" autofocus="autofocus">
                <input type="hidden" id="node-input-noerr">
            </div>

            <div class="form-row node-text-editor-row" style="position:relative">
                <div style="position: absolute; right:0; bottom: calc(100% + 3px);"><button id="node-function-expand-js" class="red-ui-button red-ui-button-small"><i class="fa fa-expand"></i></button></div>
                <div style="height: 220px; min-height:120px; margin-top: 30px;" class="node-text-editor" id="node-input-func-editor" ></div>
            </div>

            <div class="form-row" style="margin-bottom: 0px">
                <label for="node-input-outputs"><i class="fa fa-random"></i> <span data-i18n="function.label.outputs"></span></label>
                <input id="node-input-outputs" style="width: 60px;" value="1">
            </div>

        </div>

        <div id="func-tab-finalize" style="display:none">
            <div class="form-row" style="margin-bottom: 0px;">
                <input type="hidden" id="node-input-finalize" autofocus="autofocus">
            </div>
            <div class="form-row node-text-editor-row" style="position:relative">
                <div style="position: absolute; right:0; bottom: calc(100% + 3px);"><button id="node-finalize-expand-js" class="red-ui-button red-ui-button-small"><i class="fa fa-expand"></i></button></div>
                <div style="height: 250px; min-height:150px; margin-top: 30px;" class="node-text-editor" id="node-input-finalize-editor" ></div>
            </div>
        </div>

        <div id="func-tab-config" style="display:none">
            <div class="form-row" style="margin-bottom: 0px;">
                <label><i class="fa fa-wrench"></i> <span>Use Library</span></label>
            </div>
            <div class="form-row" style="height: 250px; min-height: 150px">
                <ol id="node-input-libs-container"></ol>
            </div>
        </div>
    </div>

</script>

<script type="text/javascript">
    // object that maps from library name to its descriptor
    var allLibs = [];

    function moduleName(module) {
        var match = /^([^@]+)@(.+)/.exec(module);
        if (match) {
            return [match[1], match[2]];
        }
        return [module, undefined];
    }

    /**
     * Add library descriptor
     * @param {string} name - library name
     */
    function addLib(info) {
        allLibs.push(info);
    } 

    /**
     * Validate library spec including conflicts with other specs
     * @param {string} name - library name
     */
    function checkLib(spec) {
        var [name, ver] = moduleName(spec);
        var libs = $("#node-input-libs-container").editableList("items");
        var count = 0;
        libs.each(function(i) {
            if (count > 1) {
                return;
            }
            var item = $(this);
            var n = item.find(".node-input-libs-val").val();
            if (n && (n !== "")) {
                var [name1, ver1] = moduleName(n);
                if (name1 === name) {
                    count++;
                }
            }
        });
        return (count <= 1);
    }

    /**
     * Get library list
     */
    function getModules() {
        var root = RED.settings.apiRootUrl || "";
        var promise = $.ajax({
            url: root + "/modules",
            type: "GET",
            cache: false
        });
        return promise;
    }

    /**
     * Check and update in progress state of modules
     */
    function checkInProgress(allLibs) {
        var waitTime = 1000;

        function update() {
            map = {};
            allLibs.forEach(function (lib) {
                if (lib.inProgress) {
                    map[lib.name] = lib;
                }
            });
            getModules().then(function (data,textStatus,xhr) {
                var count = 0;
                data.forEach(lib => {
                    var name = lib.name;
                    if (lib.inProgress) {
                        count++;
                    }
                    else if (name in map) {
                        var lib2 = map[name];
                        if (lib2) {
                            delete map[name];
                            var cb = lib2.onReady;
                            if (cb) {
                                lib2.version = lib.version;
                                lib2.status["installed"] = true;
                                lib2.inProgress = false;
                                cb();
                            }
                        }
                    }
                });
                if (count > 0) {
                    setTimeout(update, waitTime);
                }
            });
        }
        setTimeout(update, waitTime);
    }


    /**
     * Update library list
     */
    function updateLib(node, done) {
        var names = {};
        var specs = {};
        var libs = node.libs || [];
        allLibs = [];
        libs.forEach(lib => {
            var vname = lib.vname;
            var spec = lib.spec;
            var [name, ver] = moduleName(spec);
            var item = {
                vname: vname,
                name: name,
                spec: spec,
                status: { "edit":true }
            };
            addLib(item);
            specs[spec] = true;
            names[name] = true;
        });
        RED.nodes.eachNode(function(n) {
            if ((n.type === "function") && (n !== node)) {
                var libs = n.libs || [];
                libs.forEach(lib => {
                    var spec = lib.spec;
                    var [name, ver] = moduleName(spec);
                    if (name in names) {
                        var items = allLibs.filter(item => (item.name === name));
                        items.forEach(item => {
                            item.status["used"] = true;
                        });
                        if (spec in specs) {
                            // olready found
                            return;
                        }
                        // spec conflict
                    }
                    var item = {
                        name: name,
                        spec: spec,
                        status: { "used": true }
                    };
                    addLib(item);
                    names[name] = true;
                    specs[spec] = true;
                });
            }
        });
        var inProgressCount = 0;
        getModules().then(function(data,textStatus,xhr) {
            data.forEach(lib => {
                var name = lib.name;
                var version = lib.version;
                var preinstalled = (lib.status == "preinstalled");
                var spec = lib.spec;
                var items = allLibs.filter(item => (item.name === name));
                if (items.length > 0) {
                    items.forEach(item => {
                        item.version = version;
                        item.status["installed"] = true;
                        item.status["preinstalled"] = preinstalled;
                        item.inProgress = lib.inProgress;
                    });
                }
                else {
                    var item = {
                        name: name,
                        spec: spec,
                        version: version,
                        status: {
                            "installed": true,
                            "preinstalled": preinstalled
                        },
                        inProgress: lib.inProgress
                    };
                    addLib(item);
                    names[name] = true;
                    specs[spec] = true;
                }
                if (lib.inProgress) {
                    inProgressCount++;
                }
            });
            $("#node-input-libs-container").editableList("empty");
            allLibs.forEach(function(lib) {
                $("#node-input-libs-container").editableList("addItem", lib);
            });
            if (inProgressCount > 0) {
                checkInProgress(allLibs);
            }

            if (done) {
                done();
            }
        });
    }

    /**
     * Uninstall NPM module
     */
    function uninstallModule(node, spec, name, version,
                             moduleInfo, installButton,
                             installInfoRow, installedInfo,
                             removeButton,
                             progressRow,
                             done) {
        var root = RED.settings.apiRootUrl || "";
        progressRow.show();
        $.ajax({
            url: root + "/modules/" +spec,
            type: "DELETE",
        }).then(function(data,textStatus,xhr) {
            moduleInfo.attr("disabled", false);
            installButton.attr("disabled", false);
            installInfoRow.hide();
            installedInfo.val("");
            removeButton.show();
            progressRow.hide();

            RED.notify("Successfully uninstalled:" +name);
            if(done) {
                done();
            }
        }).fail(function(xhr,textStatus,err) {
            progressRow.hide();
            RED.notify("Failed to uninstall: " +name);
            if (done) {
                done();
            }
        });
    }

    /**
     * Updaate or Install NPM module
     */
    function updateModule(node, spec, update,
                          moduleInfo, installButton,
                          installInfoRow, installedInfo, removeButton,
                          progressRow,
                          done) {
        var [name, version] = moduleName(spec); 
        var root = RED.settings.apiRootUrl || "";
        var errorMessage = "failed to "+(update ? "update": "install") +": " +name;
        progressRow.show();
        $.ajax({
            url: root + "/modules",
            type: "POST",
            contentType: "application/json; charset=utf-8",
            cache: false,
            data: JSON.stringify({
                spec: spec,
                update: update
            })
        }).then(function(data) {
            getModules().then(function(data,textStatus,xhr) {
                var item = data.find(lib => (lib.name === name));
                progressRow.hide();
                if (item) {
                    moduleInfo.attr("disabled", true);
                    installButton.attr("disabled", true);
                    installInfoRow.show();
                    installedInfo.val(item.name+"@"+item.version);
                    removeButton.hide();

                    var msg = "Successfully "
                        +(update ? "updated": "installed")
                        +": " +name;
                    
                    RED.notify(msg);
                }
                if (done) {
                    done();
                }
            }).fail(function(xhr,textStatus,err) {
                progressRow.hide();
                RED.notify(errorMessage);
                if (done) {
                    done();
                }
            });
        }).fail(function(xhr,textStatus,err) {
            progressRow.hide();
            RED.notify(errorMessage);
            if (done) {
                done();
            }
        });
    }

    /**
     * 
     */
    function withNotification(msg, text, cb) {
        var notification = RED.notify(msg, {
            modal: true,
            fixed: true,
            buttons: [
                {
                    text: RED._("common.label.cancel"),
                    click: function() {
                        notification.close();
                    }
                },
                {
                    text: text,
                    class: "primary red-ui-palette-module-install-confirm-button-update",
                    click: function() {
                        notification.close();
                        cb();
                    }
                },
            ]
        });
    }

    function prepareLibraryConfig(node) {
        $("#node-input-libs-container").css('min-height','250px').css('min-width','450px').editableList({
            addItem: function(container,i,opt) {
                var parent = container.parent();
                var removeButton = parent.find(".red-ui-editableList-item-remove");
                var disabled = (opt && !!opt.unused);
                var row0 = $("<div/>").appendTo(container);
                var fvar = $("<input/>", {
                    class: "node-input-libs-var",
                    placeholder: RED._("node-red:function.require.var"),
                    type: "text",
                    disabled: disabled
                }).css({
                    width: "90px",
                    "margin-left": "5px"
                }).appendTo(row0);
                var fieldWidth = "260px";
                var fmodule = $("<input/>", {
                    class: "node-input-libs-val",
                    placeholder: RED._("node-red:function.require.module"),
                    type: "text",
                    disabled: disabled
                }).css({
                    width: fieldWidth,
                    "margin-left": "5px"
                }).appendTo(row0);

                var buttonWidth = "70px";
                var install = $("<button/>", {
                    class: "red-ui-button red-ui-button-small"
                }).css({
                    "margin-left": "10px",
                    width: buttonWidth
                }).appendTo(row0);;
                $("<i/>", {
                    class: "fa fa-cube"
                }).appendTo(install);
                $("<span/>").css({
                    "margin-left": "5px"
                }).text("Install").appendTo(install);

                var warn = $("<span/>").css({
                    "margin-left": "10px"
                }).appendTo(row0);
                $("<i/>", {
                    class: "fa fa-warning"
                }).appendTo(warn);
                RED.popover.tooltip(warn, "module spec conflict");
                warn.hide();

                var row1 = $("<div/>").css({
                    "margin-top": "5px"
                }).appendTo(container);

                var linstalled = $("<label/>").css({
                    width: "90px",
                    "text-align": "right",
                    "margin-right": "10px"
                }).appendTo(row1);
                $("<i/>", {
                    class: "fa fa-cube"
                }).appendTo(linstalled);
                var status = "Installed";
                $("<span/>").css({
                    "margin-left": "5px"
                }).text(status).appendTo(linstalled);

                var finstalled = $("<input/>", {
                    type: "text",
                    disabled: true
                }).css({
                    width: fieldWidth
                }).appendTo(row1);

                var uninstall = $("<button/>", {
                    class: "red-ui-button red-ui-button-small"
                }).css({
                    "margin-left": "10px",
                    width: buttonWidth
                }).appendTo(row1);
                $("<i/>", {
                    class: "fa fa-trash"
                }).appendTo(uninstall);
                $("<span/>").css({
                    "margin-left": "5px"
                }).text("Uninstall").appendTo(uninstall);

                var update = $("<button/>", {
                    class: "red-ui-button red-ui-button-small"
                }).css({
                    "margin-left": "10px",
                    width: buttonWidth
                }).appendTo(row1);
                $("<i/>", {
                    class: "fa fa-refresh"
                }).appendTo(update);
                $("<span/>").css({
                    "margin-left": "5px"
                }).text("Update").appendTo(update);

                var row2 = $("<div/>", {
                    class: "red-ui-palette-module-shade"
                }).appendTo(container);
                $("<img/>", {
                    src: "red/images/spin.svg",
                    class: "red-ui-palette-spinner"
                }).appendTo(row2);
                row2.hide();

                fvar.on("change", function (e) {
                    opt.vname = $(this).val();
                });

                fmodule.on("change", function (e) {
                    var val = $(this).val();
                    if (!checkLib(val, opt.id)) {
                        $(this).addClass("input-error");
                        warn.show();
                    }
                    else {
                        $(this).removeClass("input-error");
                        warn.hide();
                        if (val && (val !== "") &&
                            (!opt.version || (opt.version === ""))) {
                            install.attr("disabled", false);
                        }
                    }
                    opt.spec = val;
                });

                install.on("click", function (e) {
                    withNotification(
                        "Install NPM Module " +opt.spec,
                        "Install",
                        function (cb) {
                            updateModule(
                                node, opt.spec, false,
                                fmodule, install,
                                row1, finstalled, removeButton,
                                row2,
                                cb);
                        });
                });
                uninstall.on("click", function (e) {
                    withNotification(
                        "Uninstall NPM Module "+opt.spec,
                        "Uninstall",
                        function (cb) {
                            uninstallModule(
                                node, opt.spec, opt.name, opt.version,
                                fmodule, install,
                                row1, finstalled,
                                removeButton,
                                row2,
                                cb);
                        });
                });
                update.on("click", function (e) {
                    withNotification(
                        "Update NPM Module " +opt.spec,
                        "Update",
                        function (cb) {
                            updateModule(
                                node, opt.spec, true,
                                fmodule, install,
                                row1, finstalled, removeButton,
                                row2,
                                cb);
                        });
                });

                install.attr("disabled", true);
                if (opt) {
                    function updateData(data) {
                        if (data.vname && (data.vname !== "")) {
                            fvar.val(data.vname);
                        }
                        if (data.spec && (data.spec !== "")) {
                            fmodule.val(data.spec);
                        }
                        if (data.version && (data.version !== "")) {
                            fmodule.prop("disabled", true);
                            row1.show();
                            removeButton.hide();
                            finstalled.val(data.name+"@"+data.version)
                            if (data.status["preinstalled"]) {
                                uninstall.attr("disabled", true);
                                update.attr("disabled", true);
                            }
                        }
                        else {
                            install.attr("disabled", false);
                            row1.hide();
                            removeButton.show();
                        }
                    }
                    updateData(opt);
                    if (opt.inProgress) {
                        row2.show();
                        opt.onReady = function () {
                            row2.hide();
                            updateData(opt);
                            opt.onReady = null;
                        };
                    }
                }
            },
            removable: true,
            sortable: true
        });
        updateLib(node, function () {
        });
    }

    RED.nodes.registerType('function',{
        color:"#fdd0a2",
        category: 'function',
        defaults: {
            name: {value:""},
            func: {value:"\nreturn msg;"},
            outputs: {value:1},
            noerr: {value:0,required:true,validate:function(v) { return !v; }},
            initialize: {value:""},
            finalize: {value:""},
            libs: {value: []}
        },
        inputs:1,
        outputs:1,
        icon: "function.svg",
        label: function() {
            return this.name||this._("function.function");
        },
        labelStyle: function() {
            return this.name?"node_label_italic":"";
        },
        oneditprepare: function() {
            var that = this;

            var tabs = RED.tabs.create({
                id: "func-tabs",
                onchange: function(tab) {
                    $("#func-tabs-content").children().hide();
                    $("#" + tab.id).show();
                }
            });
            tabs.addTab({
                id: "func-tab-init",
                label: that._("function.label.initialize")
            });
            tabs.addTab({
                id: "func-tab-body",
                label: that._("function.label.function")
            });
            tabs.addTab({
                id: "func-tab-finalize",
                label: that._("function.label.finalize")
            });
            tabs.addTab({
                id: "func-tab-config",
                label: "Config"
            });

            tabs.activateTab("func-tab-body");

            $( "#node-input-outputs" ).spinner({
                min:0,
                change: function(event, ui) {
                    var value = this.value;
                    if (!value.match(/^\d+$/)) { value = 1;  }
                    else if (value < this.min) { value = this.min; }
                    if (value !== this.value) { $(this).spinner("value", value); }
                }
            });

            var buildEditor = function(id, value, defaultValue) {
                var editor = RED.editor.createEditor({
                    id: id,
                    mode: 'ace/mode/nrjavascript',
                    value: value || defaultValue || "",
                    globals: {
                        msg:true,
                        context:true,
                        RED: true,
                        util: true,
                        flow: true,
                        global: true,
                        console: true,
                        Buffer: true,
                        setTimeout: true,
                        clearTimeout: true,
                        setInterval: true,
                        clearInterval: true
                    }
                });
                if (defaultValue && value === "") {
                    editor.moveCursorTo(defaultValue.split("\n").length - 1, 0);
                }
                return editor;
            }
            this.initEditor = buildEditor('node-input-init-editor',$("#node-input-initialize").val(),RED._("node-red:function.text.initialize"))
            this.editor = buildEditor('node-input-func-editor',$("#node-input-func").val())
            this.finalizeEditor = buildEditor('node-input-finalize-editor',$("#node-input-finalize").val(),RED._("node-red:function.text.finalize"))

            RED.library.create({
                url:"functions", // where to get the data from
                type:"function", // the type of object the library is for
                editor:this.editor, // the field name the main text body goes to
                mode:"ace/mode/nrjavascript",
                fields:[
                    'name', 'outputs',
                    {
                        name: 'initialize',
                        get: function() {
                            return that.initEditor.getValue();
                        },
                        set: function(v) {
                            that.initEditor.setValue(v||RED._("node-red:function.text.initialize"), -1);
                        }
                    },
                    {
                        name: 'finalize',
                        get: function() {
                            return that.finalizeEditor.getValue();
                        },
                        set: function(v) {
                            that.finalizeEditor.setValue(v||RED._("node-red:function.text.finalize"), -1);
                        }
                    },
                    {
                        name: 'info',
                        get: function() {
                            return that.infoEditor.getValue();
                        },
                        set: function(v) {
                            that.infoEditor.setValue(v||"", -1);
                        }
                    }
                ],
                ext:"js"
            });
            this.editor.focus();


            var expandButtonClickHandler = function(editor) {
                return function(e) {
                    e.preventDefault();
                    var value = editor.getValue();
                    RED.editor.editJavaScript({
                        value: value,
                        width: "Infinity",
                        cursor: editor.getCursorPosition(),
                        mode: "ace/mode/nrjavascript",
                        complete: function(v,cursor) {
                            editor.setValue(v, -1);
                            editor.gotoLine(cursor.row+1,cursor.column,false);
                            setTimeout(function() {
                                editor.focus();
                            },300);
                        }
                    })
                }
            }
            $("#node-init-expand-js").on("click", expandButtonClickHandler(this.initEditor));
            $("#node-function-expand-js").on("click", expandButtonClickHandler(this.editor));
            $("#node-finalize-expand-js").on("click", expandButtonClickHandler(this.finalizeEditor));

            RED.popover.tooltip($("#node-init-expand-js"), RED._("node-red:common.label.expand"));
            RED.popover.tooltip($("#node-function-expand-js"), RED._("node-red:common.label.expand"));
            RED.popover.tooltip($("#node-finalize-expand-js"), RED._("node-red:common.label.expand"));

            prepareLibraryConfig(that);
        },
        oneditsave: function() {
            var node = this;
            var noerr = 0;
            $("#node-input-noerr").val(0);

            var disposeEditor = function(editorName,targetName,defaultValue) {
                var editor = node[editorName];
                var annot = editor.getSession().getAnnotations();
                for (var k=0; k < annot.length; k++) {
                    if (annot[k].type === "error") {
                        noerr += annot.length;
                        break;
                    }
                }
                var val = editor.getValue();
                if (defaultValue) {
                    if (val.trim() == defaultValue.trim()) {
                        val = "";
                    }
                }
                editor.destroy();
                delete node[editorName];
                $("#"+targetName).val(val);
            }
            disposeEditor("editor","node-input-func");
            disposeEditor("initEditor","node-input-initialize", RED._("node-red:function.text.initialize"));
            disposeEditor("finalizeEditor","node-input-finalize", RED._("node-red:function.text.finalize"));

            $("#node-input-noerr").val(noerr);
            this.noerr = noerr;

            var libs = $("#node-input-libs-container").editableList("items");
            var oldLibs = node.libs || [];
            var newLibs = [];
            node.libs = newLibs;
            libs.each(function(i) {
                var item = $(this);
                var v = item.find(".node-input-libs-var").val();
                var n = item.find(".node-input-libs-val").val();
                if ((!v || (v === "")) ||
                    (!n || (n === ""))) {
                    return;
                }
                newLibs.push({
                    vname: v,
                    spec: n
                });
            });
        },
        oneditcancel: function() {
            var node = this;

            node.editor.destroy();
            delete node.editor;

            node.initEditor.destroy();
            delete node.initEditor;

            node.finalizeEditor.destroy();
            delete node.finalizeEditor;
        },
        oneditresize: function(size) {
            var rows = $("#dialog-form>div:not(.node-text-editor-row)");
            var height = $("#dialog-form").height();
            for (var i=0; i<rows.length; i++) {
                height -= $(rows[i]).outerHeight(true);
            }
            var editorRow = $("#dialog-form>div.node-text-editor-row");
            height -= (parseInt(editorRow.css("marginTop"))+parseInt(editorRow.css("marginBottom")));
            $(".node-text-editor").css("height",height+"px");
            this.editor.resize();

            var height = size.height;
            $("#node-input-init-editor").css("height", (height -105)+"px");
            $("#node-input-func-editor").css("height", (height -145)+"px");
            $("#node-input-finalize-editor").css("height", (height -105)+"px");

            this.initEditor.resize();
            this.editor.resize();
            this.finalizeEditor.resize();

            $("#node-input-libs-container").css("height", (height -155)+"px");
        }
    });
</script>