sky.js/sky.base.js

var SKY = null;

(function(){
        var options = {
            url: "/",
            types: {
            }
        }

        var refreshTimer = null;
        var refreshInterval = null;
        var refreshList = [];
        var refreshCounter = 0;

        class SKYBase
        {
            constructor(){
                this._html = $();
            }

            html(html){
                if (arguments.length)
                {
                    this._html = html;
                    return this;
                }
                return this._html;
            }

            on( evName, h ){
                if (!self[evName])
                    self[evName] = [];
                self[evName].push(h);

                return this;
            }
            off( evName ){
                self[evName] = []

                return this;
            }
            fire( evName, p ){
                if (self[evName])
                    self[evName].forEach( function(h){ h(p); } );

                return this;
            }

        }

        function SkyAPI(){
            this.options = function(o){
                options = Object.assign(options, o);
            }


            /* Refresh API */
            this.refresh = function( name, interval, f){
                if (!interval)
                {
                    for (var n=0;n<refreshList.length;n++)
                        if (refreshList[n].name == name){
                            refreshList.splice(n,1);
                            break;
                        }
                } else {
                    var ritem = null;
                    for (var n=0;n<refreshList.length;n++)
                        if (refreshList[n].name == name){
                            ritem = refreshList[n];
                            break;
                        }

                    if (!ritem)
                    {
                        ritem = {
                            name: name,
                            interval: interval,
                            refresh: f,
                            counter: interval
                        }
                        refreshList.push( ritem );
                    } else {
                        ritem.interval = interval;
                        ritem.counter = interval;
                        ritem.refresh = f;
                    }

                    
                }

                return this;
            }

            this.interval = function(i){
                if (arguments.length == 0)
                    return refreshInterval;

                if (refreshTimer){
                    clearInterval( refreshTimer );
                    refreshTimer = null;
                }
                if (i)
                {
                    refreshInterval = i;
                    refreshTimer = setInterval(
                        function(){
                            refreshList.forEach( function(r){
                                r.counter -= refreshInterval;
                                if (r.counter <= 0)
                                {
                                    r.counter += r.interval;
                                    r.refresh();
                                }
                            });
                        },
                        refreshInterval
                    );
                }
                return this;
            }

            /* Types API */
            var types = {}
            var defaultType = null;

            this.type = function(name,type){
                switch (arguments.length){
                    case 0:
                        return types;
                    case 1:
                        if (defaultType.isPrototypeOf(name))
                            return name;
                            
                        if ((name == null) || (!types[name]))
                            return defaultType;
                        return types[name];
                    case 2:
                        if (type)
                            if (name != null)
                                types[name] = type;
                            else
                                defaultType = type;
                        else
                            if (name != null)
                                delete types[name];
                }
            }
            
            this.tools = {
                ntos: function(n,l){
                    n = n.toString();
                    while (n.length < l){
                        n = "0" + n;
                    }
                    return n;
                }
            }


            /* Final construction */
            this.fn = {};
            this.prototypes = {}
            this.prototypes.SKYBase = SKYBase;

            this.interval( 100 );

            return this;
        }
        SKY = new SkyAPI();
}());



function SKYAPI(baseurl){
    
    this.baseurl = baseurl;
    this.refresh = []
    
    this.setBaseURL = function(url){ this.baseurl = url; }
    this.addRefresh = function( rh, seconds = null ){ this.refresh.push( { interval: seconds ? seconds : 5, refresh: rh } ); }
        
    this.get = function(page, json, handler = null){ return this.__request("GET", page, json, handler); }
    this.post = function(page, json, handler = null){ return this.__request("POST", page, json, handler); }
    this.put = function(page, json, handler = null){ return this.__request("PUT", page, json, handler); }
    
    this.__request = function(method, page, json, handler = null){
        if (page[0] == '/')
            page = page.substr(1);
        var async = (handler) ? true : false;
            
        var x = new XMLHttpRequest();
        if (async)
        {
            x.onload = function(){
                var responseText = x.responseText;
                if (json && !content)
                    handler( JSON.parse( responseText ) );
                else
                    handler( responseText );
            }
        }
        x.open(method, this.baseurl + page, async );
        
        if (json)
            x.send(JSON.stringify(json));
        else
            x.send();
            
        if (!async)
            return x.responseText;
        return null;
    }
    
    this.getJson = function(page, handler){
        if (handler)
        {
            var j = function(t){
                    handler(JSON.parse(t));
                };
            return this.get( page, null, j );
        }
        var r = this.get( page );
        return JSON.parse(r);
    }
    
    this.call = function(endpoint,method,parameters = [], receiver = null){
        var x = new XMLHttpRequest();
        
        x.open("POST", this.baseurl + endpoint, (receiver != null));
        x.setRequestHeader("content-type","application/json");
        
        if (receiver)
        {
            x.onload = function(){ var r = JSON.parse(this.responseText).Result; receiver(r); }
            x.onerror = function(){ receiver(false); }
        }
        
        var methodCall = {
            "MethodName": method,
            "Parameters": parameters
        }
        
        x.send(JSON.stringify(methodCall));
        
        if (!receiver)
        {
            var result = JSON.parse(x.responseText);
            if (result.Exception != null)
                throw result.Exception;

            return result.Result;
        }
        return x;
    }

    this.loadPage = function (page) {
        if (page[0] == '/')
            page = page.substr(1);
            
        var x = new XMLHttpRequest();
        
        x.open("GET", this.baseurl + page);
        x.setRequestHeader("x-template-unframed","unframed");
        x.onload = function()
        {
            $("#content").empty();
            $("#content").append(this.responseText);
            history.pushState(null, page, skyapi().baseurl + page);
        }
        
        this.refresh = []
        
        x.send();
        
        return false;
    }

    this.fireOnLoad = function(element){
        if (element.onload != null)
        {
            element.onload();
        }

        for (var n=0;n<element.children.length;n++)
            this.fireOnLoad(element.children[n]);
    }
    
    this.__refresh_index = 0;
    this.UIRefresh = function(){
    
        this.__refresh_index++;

        for (var n=0;n<this.refresh.length;n++)
        {
            var r = this.refresh[n];
            if ((this.__refresh_index % r.interval)==0)
                r.refresh();
        }
        
    }
    
    setInterval( function(){ skyapi().UIRefresh(); }, 1000 );
}

var __skyapi = new SKYAPI("/");

function skyapi()
{
    return __skyapi;
}



function ScaleSI(value)
{
    if (value > 1000000000)
        return ((value / 1000000000) | 0) + "G";
    if (value > 1000000)
        return ((value / 1000000) | 0) + "M";
    if (value > 1000)
        return ((value / 1000) | 0) + "k";
    return value;
}

function BytesToString(bytestring, sep = ":")
{
    return Array.from( bytestring, function(b){
        return ('0' + b.charCodeAt(0).toString(16)).slice(-2);
    }).join(sep);
}

function DecodeMAC(b64mac)
{
    var smac = atob(b64mac);
    return BytesToString(smac);
}

function PopulateForm( o, options = {} )
{
    var opt = Object.assign( {
            top: null,
            transform: function(v){ return v; },
            properties: {},
        }, options );

    for (const key in o)
    {
        var po = Object.assign( {
            transform: opt.transform,
        }, opt.properties[key]);
        
        var i = $("#" + key, opt.top);
        if (i.length)
            i.val( po.transform(o[key]) );
    }
}