js/ui.log.js

  1. const logger = function(ui = {}) {
  2.     
  3.     
  4.     /**
  5.     * Log a message to the console
  6.     * 
  7.     */
  8.     ui.log = async function(message) {
  9.         //console.warn(message);
  10.         const maxWaitTime = 250; // half second for node change is already too slow
  11.         var $console = $("#loadingOverlay .console");
  12.         if (!$console.is(":visible")) return console.log(message);
  13.         var texts = [];
  14.         for (var i=0; i<arguments.length; i++) {
  15.             if (typeof arguments[i] !== "string") {
  16.                 texts.push(JSON.stringify(arguments[i], undefined, 2));
  17.             } else {
  18.                 texts.push(arguments[i]);
  19.             }
  20.         }
  21.         
  22.         if (ui.log.getConfig().type) {
  23.             $console.append(`<pre data-type="${ui.log.getConfig().type}">${texts.join("\n   ")}</pre>`);
  24.         } else if (message.constructor.name == "jQuery") {
  25.             // append as is
  26.             let thisPre = $("<pre></pre>");
  27.             thisPre.append(message);
  28.             $console.append(thisPre);
  29.         } else {
  30.             $console.append("<pre>"+texts.join("\n   ")+"</pre>");
  31.         }
  32.         
  33.         console.log.apply(this, arguments);
  34.         var resolver;
  35.         var promise = new Promise((resolve, reject) => {
  36.             resolver = resolve;
  37.             ui.one("logIsAdded", async ()=>{
  38.                 resolve();
  39.             });
  40.         })
  41.         
  42.         window.setTimeout(()=>{
  43.             resolver();
  44.         }, maxWaitTime)
  45.         return promise;
  46.     }
  47.     
  48.     ui.log.isShown = function() {
  49.         return $("#loadingOverlay .console").is(":visible");
  50.     }
  51.     
  52.     ui.log.show = function(options) {
  53.         /*
  54.         options.buttons = [{
  55.         text: "text to display",
  56.         onClick : function
  57.         }]
  58.         */
  59.         options = options||{};
  60.         options.buttons = options.buttons||[];
  61.         
  62.         $("#applicationBar .appActionsLeft").hide();
  63.         
  64.         
  65.         // autofix direct options.buttons object
  66.         if (Array.isArray(options.buttons) == false) {
  67.             if (typeof options.buttons.text !== "undefined") options.buttons = [options.buttons];
  68.         }
  69.         ui.consoleIsShown = true;
  70.         $("#loadingOverlay .console").empty();
  71.         $("#loadingOverlay .loadingBarProgress").empty();
  72.         //$("#loadingOverlay .console").addClass("stickToBottom");
  73.         $("#loadingOverlay .loadingBarProgress").removeClass("stopped");
  74.         $("#loadingOverlay .loadingBarProgress").removeClass("error");
  75.         
  76.         $(".loadingBarButtons").empty();
  77.         for (var i=0; i<options.buttons.length; i++) {
  78.             var thisButton = $("<a href='#'>"+options.buttons[i].text+"</a>");
  79.             if (typeof options.buttons[i].onClick == 'function') {
  80.                 thisButton.data("onClick", options.buttons[i].onClick)
  81.                 
  82.                 thisButton.on("click", function(e) {
  83.                     $(this).data("onClick").call(this);
  84.                 });
  85.             }
  86.             
  87.             $(".loadingBarButtons").append(thisButton);
  88.         }
  89.         
  90.         
  91.         if ($("#loadingOverlay").hasClass("initialized") == false) {
  92.             $("#loadingOverlay").addClass("initialized");
  93.             ui.log.init();
  94.         }
  95.         
  96.         ui.appBarTheme("dark");
  97.         $("#loadingOverlay").removeClass("hidden");
  98.         $(document).trigger("showLoading");
  99.         
  100.         ui.log("Log started!");
  101.         ui._logTimeStart = Date.now();
  102.         if (nw.process.versions["nw-flavor"] == "sdk") ui.log(t("You can view the more detailed information on console log (F12)"));
  103.         
  104.         
  105.         return $("#loadingOverlay");
  106.     }
  108.     ui.log.start = ui.log.show;
  109.     
  110.     ui.log.hide = function(destroy) {
  111.         ui.consoleIsShown = false;
  112.         destroy = destroy||false;
  113.         $("#loadingOverlay .loadingStatus").text("");
  114.         
  115.         if (destroy) {
  116.             $("#loadingOverlay .console").empty();
  117.         }
  118.         $("#loadingOverlay").addClass("hidden");
  119.         ui.appBarTheme("");
  120.         $("#applicationBar .appActionsLeft").show();
  121.         
  122.         /**
  123.         * Triggered when loading console closed
  124.         * @event ui#loadingScreenIsClosed
  125.         * @since 4.3.20
  126.         */
  127.         ui.trigger("loadingConsoleClosed")
  128.         
  129.         return $("#loadingOverlay");
  130.     }
  131.     
  132.     ui.log.clearButtons = function() {
  133.         $(".loadingBarButtons").empty();
  134.     }
  135.     
  136.     ui.log.showCloseButton = function(options) {
  137.         options=options||{};
  138.         
  139.         var $loadingBarBtn = $(".loadingBarButtons");
  140.         if ($loadingBarBtn.find(".closeButton").length > 0) return;
  141.         
  142.         var thisButton = $("<a class='closeButton icon-cancel-1' href='#'>"+t("Close")+"</a>");
  143.         thisButton.on("click", function(e) {
  144.             ui.log.hide.call(this, true);
  145.             ui.log.clearButtons();
  146.         });
  147.         
  148.         $loadingBarBtn.append(thisButton);	
  149.     }
  150.     
  151.     ui.log.showOpenCacheButton = function(target, options) {
  152.         options=options||{};
  153.         if (typeof target == 'undefined') return false;
  154.         $(".loadingBarButtons").find(".openCache").remove();
  155.         var thisButton = $("<a href='#' class='openCache icon-folder-open'>Open Cache</a>");
  156.         thisButton.on("click", function(e) {
  157.             //var thisTmpPath = str_ireplace("\\", "\\\\", target);
  158.             //console.log("running command : \r\n"+'explorer "'+thisTmpPath+'"');
  159.             require('child_process').exec('explorer "'+target+'"' , function (err, stdout, stderr) { console.log("Explorer opened") });
  160.         });
  161.         
  162.         $(".loadingBarButtons").append(thisButton);		
  163.     }
  164.     
  165.     ui.log.addButton = function(text, onClick, options) {
  166.         options=options||{};
  167.         options.class=options.class||"";
  168.         
  169.         if (typeof text == 'undefined') return false
  170.         if (typeof onClick !== 'function') onClick = function(){};
  171.         text = text||"";
  172.         options.a = options.a||"#";
  173.         
  174.         
  175.         var thisButton = $("<a class='"+options.class+"' href='"+options.a+"'>"+text+"</a>");
  176.         thisButton.on("click", function(e) {
  177.             onClick.call(this);
  178.         });
  179.         
  180.         $(".loadingBarButtons").append(thisButton);	
  181.         return thisButton;
  182.     }
  183.     
  184.     
  185.     ui.log.stickToBottom = function($elm) {
  186.         if ($elm.length == 0) return $elm;
  187.         console.log($elm[0].scrollTop+"+"+$elm.height()+" >= "+$elm[0].scrollHeight);
  188.         if (($elm[0].scrollTop+$elm.height() >= $elm[0].scrollHeight)) {
  189.             $elm[0].scrollTop=$elm[0].scrollHeight;
  190.         }
  191.         return $elm;
  192.     }
  193.     
  194.     ui.log.progress = async function(percent, status, options) {
  195.         /*
  196.         options.mode = consoleOutput -> no pre wrapper
  197.         */
  198.         var $loading 		= $("#loadingOverlay");
  199.         options 			= options||{};
  200.         options.consoleOnly = options.consoleOnly||false;
  201.         options.mode 		= options.mode||"";
  202.         options.classStr 	= options.classStr||"";
  203.         if (typeof percent == 'string') {
  204.             //$loading.find(".loadingBarProgress").css("width", 100+"%");
  205.             $loading.find(".loadingBarProgress").css("left", "0%");
  206.             $loading.find(".loadingBarOverlay").text(percent);
  207.         } else if (typeof percent !== 'undefined') {
  208.             percent = percent||0;
  209.             percent = Math.round(percent);
  210.             //$loading.find(".loadingBarProgress").css("width", percent+"%");
  211.             $loading.find(".loadingBarProgress").css("left", (-100+percent)+"%");
  212.             $loading.find(".loadingBarOverlay").text(percent+"%");
  213.         } 
  214.         
  215.         var classStr = "";
  216.         if (options.classStr) {
  217.             classStr = ' class="'+options.classStr+'"';
  218.         }
  219.         
  220.         
  221.         if (typeof status !== "undefined") {
  222.             if (options.consoleOnly == false) {
  223.                 $loading.find(".loadingStatus").text(status);
  224.             }
  225.             var console = $("#loadingOverlay .console");
  226.             
  227.             if (options.mode == "consoleOutput") {
  228.                 console.append("<span"+classStr+">"+status+"</span>");
  229.             } else {
  230.                 console.append("<pre"+classStr+">"+status+"</pre>");
  231.             }
  232.             
  233.             /*
  234.             if (console.hasClass("stickToBottom")) {
  235.             console[0].scrollTop=console[0].scrollHeight;
  236.             }	
  237.             */	
  238.             return status;
  239.         }
  240.     }
  241.     
  242.     ui.log.addHtml = async function(html) {
  243.         const $console = $("#loadingOverlay .console");
  244.         let thisPre = $("<pre></pre>");
  245.         thisPre.append($(html));
  246.         $console.append(thisPre);
  247.     }
  248.     
  249.     ui.log.setConfig = function(config = {}) {
  250.         ui.logConfig = config;
  251.     }
  252.     
  253.     ui.log.getConfig = function() {
  254.         return ui.logConfig || {};
  255.     }
  256.     
  257.     ui.log.error = async function() {
  258.         this.setConfig({type:"error"});
  259.         await ui.log.apply(this, Array.from(arguments));
  260.         this.setConfig({type:undefined});
  261.         return;
  262.     }
  263.     
  264.     ui.log.warning = async function() {
  265.         this.setConfig({type:"warning"});
  266.         await ui.log.apply(this, Array.from(arguments));
  267.         this.setConfig({type:undefined});
  268.         return;
  269.     }
  270.     
  271.     ui.log.info = async function() {
  272.         this.setConfig({type:"info"});
  273.         await ui.log.apply(this, Array.from(arguments));
  274.         this.setConfig({type:undefined});
  275.         return;
  276.     }
  277.     
  278.     ui.log.success = async function() {
  279.         this.setConfig({type:"success"});
  280.         await ui.log.apply(this, Array.from(arguments));
  281.         this.setConfig({type:undefined});
  282.         return;
  283.     }
  284.     
  285.     ui.log.init = function() {
  286.         if (this.loadingObserverIsInitialized) return;
  287.         
  288.         // Select the node that will be observed for mutations
  289.         const targetNode = $("#loadingOverlay")[0];
  290.         
  291.         // Options for the observer (which mutations to observe)
  292.         const config = { attributes: false, childList: true, subtree: true };
  293.         
  294.         // Callback function to execute when mutations are observed
  295.         const callback = function(mutationsList, observer) {
  296.             ui.trigger("logIsAdded");
  297.         };
  298.         
  299.         // Create an observer instance linked to the callback function
  300.         const observer = new MutationObserver(callback);
  301.         
  302.         // Start observing the target node for configured mutations
  303.         observer.observe(targetNode, config);	
  304.         this.loadingObserverIsInitialized = true;
  305.     }
  306.     
  307.     
  308.     ui.log.end = function(percent, status, options) {
  309.         options = options||{};
  310.         console.log("Loading end", arguments);
  311.         var elapsed = Date.now() -  ui._logTimeStart;
  312.         ui.log("Log ended!");
  313.         ui.log("Elapsed time : "+elapsed+"ms");
  314.         ui.log.progress(percent, status, options);
  315.         var $loading = $("#loadingOverlay");
  316.         options.error = options.error || false;
  317.         
  318.         var thisClass = "stopped";
  319.         if (options.warning) thisClass = "warning";
  320.         if (options.error) thisClass = "error";
  321.         $loading.find(".loadingBarProgress").addClass(thisClass);
  322.         ui.log.showCloseButton();
  323.     }
  324.     
  325. }
  327. module.exports = logger;