many.py.js

// Generated by WYC 1.1.0 (https://github.com/manatlan/wyc)

var _pyfunc_int = function (x, base) { // nargs: 1 2
    if(base !== undefined) return parseInt(x, base);
    return x<0 ? Math.ceil(x): Math.floor(x);
};
var _pyfunc_op_contains = function op_contains (a, b) { // nargs: 2
    if (b == null) {
    } else if (Array.isArray(b)) {
        for (var i=0; i<b.length; i++) {if (_pyfunc_op_equals(a, b[i]))
                                           return true;}
        return false;
    } else if (b.constructor === Object) {
        for (var k in b) {if (a == k) return true;}
        return false;
    } else if (b.constructor == String) {
        return b.indexOf(a) >= 0;
    } var e = Error('Not a container: ' + b); e.name='TypeError'; throw e;
};
var _pyfunc_op_equals = function op_equals (a, b) { // nargs: 2
    var a_type = typeof a;
    // If a (or b actually) is of type string, number or boolean, we don't need
    // to do all the other type checking below.
    if (a_type === "string" || a_type === "boolean" || a_type === "number") {
        return a == b;
    }

    if (a == null || b == null) {
    } else if (Array.isArray(a) && Array.isArray(b)) {
        var i = 0, iseq = a.length == b.length;
        while (iseq && i < a.length) {iseq = op_equals(a[i], b[i]); i+=1;}
        return iseq;
    } else if (a.constructor === Object && b.constructor === Object) {
        var akeys = Object.keys(a), bkeys = Object.keys(b);
        akeys.sort(); bkeys.sort();
        var i=0, k, iseq = op_equals(akeys, bkeys);
        while (iseq && i < akeys.length)
            {k=akeys[i]; iseq = op_equals(a[k], b[k]); i+=1;}
        return iseq;
    } return a == b;
};
var _pyfunc_op_mult = function (a, b) { // nargs: 2
    if ((typeof a === 'number') + (typeof b === 'number') === 1) {
        if (a.constructor === String) return _pymeth_repeat.call(a, b);
        if (b.constructor === String) return _pymeth_repeat.call(b, a);
        if (Array.isArray(b)) {var t=a; a=b; b=t;}
        if (Array.isArray(a)) {
            var res = []; for (var i=0; i<b; i++) res = res.concat(a);
            return res;
        }
    } return a * b;
};
var _pyfunc_truthy = function (v) {
    if (v === null || typeof v !== "object") {return v;}
    else if (v.length !== undefined) {return v.length ? v : false;}
    else if (v.byteLength !== undefined) {return v.byteLength ? v : false;}
    else if (v.constructor !== Object) {return true;}
    else {return Object.getOwnPropertyNames(v).length ? v : false;}
};
var _pymeth_remove = function (x) { // nargs: 1
    if (!Array.isArray(this)) return this.remove.apply(this, arguments);
    for (var i=0; i<this.length; i++) {
        if (_pyfunc_op_equals(this[i], x)) {this.splice(i, 1); return;}
    }
    var e = Error(x); e.name='ValueError'; throw e;
};
var _pymeth_repeat = function(count) { // nargs: 0
    if (this.repeat) return this.repeat(count);
    if (count < 1) return '';
    var result = '', pattern = this.valueOf();
    while (count > 1) {
        if (count & 1) result += pattern;
        count >>= 1, pattern += pattern;
    }
    return result + pattern;
};
var MyBack, MyFold, MySimplest, MyTest, MyTest2;
MySimplest = function () {
    let o=Reflect.construct(HTMLElement, [], MySimplest);
    if(o._template) {
        let tpl = document.createElement('template');
        tpl.innerHTML = o._template;
        o.attachShadow({"mode": "open"}).appendChild(tpl.content.cloneNode(true));
    }
    if(o.init) o.init();
    return o;
}
MySimplest.prototype = Object.create(HTMLElement.prototype);
MySimplest.prototype._base_class = HTMLElement.prototype;
MySimplest.prototype.__name__ = "MySimplest";


MyTest = function () {
    let o=Reflect.construct(HTMLElement, [], MyTest);
    if(o._template) {
        let tpl = document.createElement('template');
        tpl.innerHTML = o._template;
        o.attachShadow({"mode": "open"}).appendChild(tpl.content.cloneNode(true));
    }
    if(o.init) o.init();
    return o;
}
MyTest.prototype = Object.create(HTMLElement.prototype);
MyTest.prototype._base_class = HTMLElement.prototype;
MyTest.prototype.__name__ = "MyTest";

MyTest.prototype.init = function () {
    this.root = this.shadowRoot.querySelector("b");
    return null;
};

MyTest.prototype.render = function () {
    this.root.innerHTML = _pyfunc_op_mult((_pyfunc_int((this.attributes["nb"].value))), "&#11088");
    return null;
};


MyTest2 = function () {
    let o=Reflect.construct(HTMLElement, [], MyTest2);
    if(o._template) {
        let tpl = document.createElement('template');
        tpl.innerHTML = o._template;
        o.attachShadow({"mode": "open"}).appendChild(tpl.content.cloneNode(true));
    }
    if(o.init) o.init();
    return o;
}
MyTest2.prototype = Object.create(HTMLElement.prototype);
MyTest2.prototype._base_class = HTMLElement.prototype;
MyTest2.prototype.__name__ = "MyTest2";

MyTest2.prototype.init = function () {
    this.mt = this.shadowRoot.querySelector("#mt");
    (this.shadowRoot.querySelector("#add").addEventListener)("click", (function (e) {return this.setAttribute("value", this.getValue() + 1);}).bind(this));
    (this.shadowRoot.querySelector("#sub").addEventListener)("click", (function (e) {return this.setAttribute("value", this.getValue() - 1);}).bind(this));
    return null;
};

MyTest2.prototype.getValue = function () {
    return _pyfunc_int((this.attributes["value"].value));
};

MyTest2.prototype.render = function () {
    this.mt.setAttribute("nb", this.getValue());
    return null;
};


MyBack = function () {
    let o=Reflect.construct(HTMLElement, [], MyBack);
    if(o._template) {
        let tpl = document.createElement('template');
        tpl.innerHTML = o._template;
        o.attachShadow({"mode": "open"}).appendChild(tpl.content.cloneNode(true));
    }
    if(o.init) o.init();
    return o;
}
MyBack.prototype = Object.create(HTMLElement.prototype);
MyBack.prototype._base_class = HTMLElement.prototype;
MyBack.prototype.__name__ = "MyBack";

MyBack.prototype.init = function () {
    this.root = this.shadowRoot.querySelector("div");
    return null;
};

MyBack.prototype.connectedCallback = function () {
    this.setAttribute("style", "cursor:pointer;");
    return null;
};

MyBack.prototype.toggle = function () {
    this.root.classList.toggle("on");
    return null;
};


MyFold = function () {
    let o=Reflect.construct(HTMLElement, [], MyFold);
    if(o._template) {
        let tpl = document.createElement('template');
        tpl.innerHTML = o._template;
        o.attachShadow({"mode": "open"}).appendChild(tpl.content.cloneNode(true));
    }
    if(o.init) o.init();
    return o;
}
MyFold.prototype = Object.create(HTMLElement.prototype);
MyFold.prototype._base_class = HTMLElement.prototype;
MyFold.prototype.__name__ = "MyFold";

MyFold.prototype.init = function () {
    this.root = this.shadowRoot.querySelector("div");
    (this.shadowRoot.querySelector("#line").addEventListener)("click", (function (e) {return this.switch();}).bind(this));
    return null;
};

MyFold.prototype.connectedCallback = function () {
    this.setTitle((_pyfunc_truthy(this.getAttribute("title"))) || "");
    return null;
};

MyFold.prototype.setTitle = function (title) {
    this.shadowRoot.querySelector("#line").innerHTML = title;
    return null;
};

MyFold.prototype.setDetail = function (detail) {
    this.shadowRoot.querySelector("#detail").innerHTML = detail;
    return null;
};

MyFold.prototype.getDetail = function (detail) {
    return this.shadowRoot.querySelector("#detail").innerHTML;
};

MyFold.prototype.getOpen = function () {
    return !_pyfunc_op_contains(this.getAttribute("open"), [null, 0, false, "0", "false", "no", "null"]);
};

MyFold.prototype.switch = function () {
    this.setAttribute("open", !_pyfunc_truthy(this.getOpen()));
    return null;
};

MyFold.prototype.openclose = function () {
    var a;
    a = Array.prototype.slice.call(arguments);
    if (_pyfunc_truthy(this.getOpen())) {
        this.root.classList.add("open");
    } else {
        _pymeth_remove.call(this.root.classList, "open");
    }
    this.dispatchEvent(new window.Event("change"));
    return null;
};

//================================================================== MySimplest (my-simplest)
Object.defineProperty(MySimplest, 'observedAttributes', {
    get: function() { return []; }
});

MySimplest.prototype._template = `
    <style>
    div {background:yellow}
    </style>

    <div>Hello World</div>
    `;
MySimplest.prototype._reacts = {};

MySimplest.prototype.attributeChangedCallback = function (attr, old_value, new_value) {
    if( this._reacts[attr] ) {
        for(var idx in this._reacts[attr]) {
            let method=this._reacts[attr][idx]
            this[method](); // call reacted method
        }
    }
};

customElements.define("my-simplest", MySimplest);

//================================================================== MyTest (my-test)
Object.defineProperty(MyTest, 'observedAttributes', {
    get: function() { return ['nb']; }
});

MyTest.prototype._template = `
    <style>
    * {background:red}
    </style>

    <b>Kaputt</b>
    `;
MyTest.prototype._reacts = {'nb': ['render']};

MyTest.prototype.attributeChangedCallback = function (attr, old_value, new_value) {
    if( this._reacts[attr] ) {
        for(var idx in this._reacts[attr]) {
            let method=this._reacts[attr][idx]
            this[method](); // call reacted method
        }
    }
};

customElements.define("my-test", MyTest);

//================================================================== MyTest2 (my-test2)
Object.defineProperty(MyTest2, 'observedAttributes', {
    get: function() { return ['value']; }
});

MyTest2.prototype._template = `
    <style>
    div {background:green}
    </style>

    <div>
        <button id="sub">-</button>
        <button id="add">+</button>
        <my-test id="mt"></my-test>
    </div>
    `;
MyTest2.prototype._reacts = {'value': ['render']};

MyTest2.prototype.attributeChangedCallback = function (attr, old_value, new_value) {
    if( this._reacts[attr] ) {
        for(var idx in this._reacts[attr]) {
            let method=this._reacts[attr][idx]
            this[method](); // call reacted method
        }
    }
};

customElements.define("my-test2", MyTest2);

//================================================================== MyBack (my-back)
Object.defineProperty(MyBack, 'observedAttributes', {
    get: function() { return []; }
});

MyBack.prototype._template = `
    <style>
        div      {background:black;padding:4px;color:red;border:4px solid black}
        div    > span {display: none}

        div.on   {border:4px solid red}
        div.on > span {display: block;position:absolute;top:0px;right:0px;background:#888}
    </style>

    <div>
        CLICK
        <span>XXX</span>
    </div>
    `;
MyBack.prototype._reacts = {};

MyBack.prototype.attributeChangedCallback = function (attr, old_value, new_value) {
    if( this._reacts[attr] ) {
        for(var idx in this._reacts[attr]) {
            let method=this._reacts[attr][idx]
            this[method](); // call reacted method
        }
    }
};

customElements.define("my-back", MyBack);

//================================================================== MyFold (my-fold)
Object.defineProperty(MyFold, 'observedAttributes', {
    get: function() { return ['open']; }
});

MyFold.prototype._template = `
    <style>
        div#line {cursor:pointer}
        div#line::before {content: "▶ " }
        div#detail {display:none;margin-left:8px}
        div.open > div#line::before {content: "▼ "}
        div.open > div#detail {display:inherit}
    </style>
    <div>
        <div id="line"></div>
        <div id="detail"><slot/></div>
    <div>
    `;
MyFold.prototype._reacts = {'open': ['openclose']};

MyFold.prototype.attributeChangedCallback = function (attr, old_value, new_value) {
    if( this._reacts[attr] ) {
        for(var idx in this._reacts[attr]) {
            let method=this._reacts[attr][idx]
            this[method](); // call reacted method
        }
    }
};

customElements.define("my-fold", MyFold);