efront 3.23.0 → 3.24.5

package/coms/kugou/player.js

@@ -143,11 +143,11 @@ var $scope = {
     },
     draw(buf) {
         if (!player || !player.offsetHeight || !$scope.dance) return;
-        buf = [].map.call(buf, a => (a / 128.0 - 1) * 2 / 9 + 0.6);
+        buf = Array.prototype.map.call(buf, a => (a / 128.0 - 1) * 2 / 9 + 0.6);
         var width = freePixel(player.offsetWidth);
         var height = 72;
         var ratio = 1 / width * buf.length;
-        var buf = [].map.call(buf, (y, i) => [i / buf.length, y]);
+        var buf = Array.prototype.map.call(buf, (y, i) => [i / buf.length, y]);
         var { sin, cos } = Math;
         var { currentTheta } = $scope;
         if (player.offsetHeight <= calcPixel(80)) {
@@ -179,6 +179,7 @@ var $scope = {
             cast($scope.dance, buf);
         }
     },
+    playid: 0,
     play(hash = musicList.active_hash) {
         render.refresh();
         var isPlayback = typeof hash === "number";
@@ -237,6 +238,7 @@ var $scope = {
         $scope.playing = true;
         playState.width = 0;
         getMusicInfo(hash).loading_promise.then((response) => {
+            console.log(response)
             if (!this.playing) return;
             if (hash !== musicList.active_hash) return;
             if (response.imgUrl) {

package/coms/kugou/song.html

@@ -1,7 +1,7 @@
 <div class="bg"></div>
 <png class="logo" ng-if="song.imgurl" ng-src=song.imgurl></png>
+<div class="singer" ng-if="song.singer" ng-model=song.singerMarked></div>
 <div class="song" ng-model=song.songMarked></div>
-<div class="singer" ng-model=song.singerMarked></div>
 <div class="filterTime(song.timeLength)"></div>
 <div refresh class="play-state" ng-if="song.hash===musicList.active_hash" ng-class={error:playState.error}>
     <div ng-style="{width:playState.width}"></div>

package/coms/kugou/song.js

@@ -21,6 +21,7 @@ function main(elem) {
         $scope.song = {
             hash: item.hash,
             imgurl: item.imgurl,
+            singer: singerName,
             songMarked: mark(songName, elem.mark),
             singerMarked: mark(singerName, elem.mark)
         };

package/coms/kugou/song.less

@@ -24,19 +24,23 @@
     width: 40px;
     margin: -6px -4px;
 
+    &+.singer+.song,
     &+.song {
         margin-left: -38px;
         padding-left: 46px;
-        line-height: 30px;
         display: inline-block;
         vertical-align: top;
+
     }
+
+    &+.singer {
+        padding-left: 46px;
+    }
+
 }
 
 >.song {
-    width: 100%;
-    overflow: hidden;
-    text-overflow: ellipsis;
+    line-height: 30px;
 }
 
 b {
@@ -56,6 +60,10 @@ b {
     line-height: 12px;
     font-size: 12px;
     color: #888;
+
+    &+.song {
+        padding-top: 6px;
+    }
 }
 
 >.play-state {

package/coms/zimoli/Promise.js

@@ -4,177 +4,128 @@ var setTimeout = window.setTimeout;
 var Function = window.Function;
 var console = window.console;
 var Error = window.Error;
+var requestAnimationFrame = window.setImmediate || window.setTimeout;
 var isFunction = function (f) {
     return typeof f === "function";
 };
 if (window.Promise) {
     var Promise = window.Promise;
 } else {
-    var isPromise = function (pendding) {
-        return pendding instanceof Promise || pendding && isFunction(pendding.then) && isFunction(pendding.catch);
+    var isThenable = function (pendding) {
+        return pendding instanceof Promise || pendding && isFunction(pendding.then);
     };
-
-    var concat = function (okfun, ohfun, oks, ohs) {
-        var _oked, _ohed, _ok, _oh, removeed;
-        var runable = function (ok, oh) {
-            if (_oked) {
-                ok.apply(null, _oked);
-            } else if (_ohed) {
-                oh.apply(null, _ohed);
-            } else {
-                _ok = ok;
-                _oh = oh;
-            }
-        };
-        var _promise = new Promise(runable);
-        var onpermit = function (f, args) {
-            if (!removeed) {
-                try {
-                    var pendding = f.apply(null, args);
-                    if (_ok) _ok(pendding);
-                    else _oked = [pendding];
-                } catch (e) {
-                    if (_oh) _oh(e);
-                    else _ohed = [e];
+    var queue = [];
+    var run = function (q) {
+        var threads = queue.splice(0, queue.length);
+        for (var t of threads) {
+            if (t.oked) {
+                for (var r of t.PromiseFulfillReactions) {
+                    r.apply(null, t.oked);
                 }
-                removeed = true;
-            }
-        };
-        var onresolve = function () {
-            if (okfun instanceof Function) onpermit(okfun, arguments);
-            if (!removeed) {
-                if (_ok) _ok.apply(null, arguments);
-                else _oked = arguments;
-                removeed = true;
             }
-        };
-        var onreject = function () {
-            if (ohfun instanceof Function) onpermit(ohfun, arguments);
-            if (!removeed) {
-                if (_oh) _oh.apply(null, arguments);
-                else _ohed = arguments;
-                removeed = true;
+            if (t.ohed) {
+                if (!t.PromiseRejectReactions.length) throw `未处理的异常:${t.ohed}`;
+                for (var r of t.PromiseRejectReactions) {
+                    r.apply(null, t.ohed);
+                }
             }
-        };
-        oks.push(onresolve);
-        ohs.push(onreject);
-        return _promise;
-    }
-
+            t.PromiseRejectReactions.splice(0, t.PromiseRejectReactions.length);
+            t.PromiseFulfillReactions.splice(0, t.PromiseFulfillReactions.length);
+        }
+    };
+    var fire = function (p) {
+        if (queue.length) return queue.push(p);
+        queue.push(p);
+        requestAnimationFrame(run);
+    };
     var Promise = function (executor) {
-        var PromiseFulfillReactions = this.PromiseFulfillReactions = [], //thens
-            PromiseRejectReactions = this.PromiseRejectReactions = [], //catches
-            oked = this.oked, ohed = this.ohed;
+        this.PromiseFulfillReactions = []; //thens
+        this.PromiseRejectReactions = []; //catches
+        this.oked = this.ohed = null;
 
         var ResolvingFunctions_resolve = (result) => { //ok
-            if (isPromise(result)) {
-                result.then(ResolvingFunctions_resolve).catch(ResolvingFunctions_reject);
+            if (this.oked || this.ohed) return;
+            if (isThenable(result)) {
+                result.then(ResolvingFunctions_resolve, ResolvingFunctions_reject);
             } else {
-                oked = this.oked = arguments;
-                this.run(PromiseFulfillReactions, oked);
+                this.oked = arguments;
+                fire(this);
             }
         };
 
         var ResolvingFunctions_reject = (e) => { //oh
-            ohed = this.ohed = arguments;
-            this.run(PromiseRejectReactions, ohed);
+            if (this.oked || this.ohed) return;
+            this.ohed = arguments;
+            fire(this);
         };
-
-        try {
-            executor(ResolvingFunctions_resolve, ResolvingFunctions_reject);
-        } catch (e) {
-            ResolvingFunctions_reject(e);
-        }
+        executor(ResolvingFunctions_resolve, ResolvingFunctions_reject);
     };
     Promise.prototype = {
         then(onok, onoh) {
-            var _promise = concat(onok, onoh, this.PromiseFulfillReactions, this.PromiseRejectReactions);
-            this.oked && this.run(this.PromiseFulfillReactions, this.oked);
-            this.ohed && this.run(this.PromiseRejectReactions, this.ohed);
-            return _promise;
+            var resolve, reject;
+            var promise = new Promise(function (ok, oh) {
+                if (onok) resolve = function (a) {
+                    try {
+                        a = onok(a);
+                        ok(a);
+                    } catch (e) {
+                        oh(e);
+                    }
+                };
+                if (onoh) reject = function (a) {
+                    try {
+                        a = onoh(a);
+                        ok(a);
+                    } catch (e) {
+                        oh(e);
+                    }
+                };
+            })
+            if (resolve) this.PromiseFulfillReactions.push(resolve);
+            if (reject) this.PromiseRejectReactions.push(reject);
+            if (this.oked || this.ohed) fire(this);
+            return promise;
         },
         catch(f) {
             return this.then(null, f);
         },
-        run(threads, args) {
-            if (threads.pendding) return;
-            threads.pendding = true;
-            setTimeout(_ => {
-                do {
-                    var next = threads.shift();
-                    if (next instanceof Function) {
-                        next.apply(null, args);
-                    }
-                } while (threads.length);
-                this.PromiseRejectReactions.splice(0, this.PromiseRejectReactions.length);
-                this.PromiseFulfillReactions.splice(0, this.PromiseFulfillReactions.length);
-                threads.pendding = false;
-            }, 0);
-        }
     }
     Promise.all = function (penddings) {
         return new Promise(function (ok, oh) {
             if (!(penddings && penddings.length)) {
                 return ok();
             }
-            try {
-                var resolved_count = 0,
-                    rejected_count = 0,
-                    results = Array(penddings.length);
-                for (var cx = 0, dx = penddings.length; cx < dx; cx++) {
-                    var pendding = penddings[cx];
-                    if (isPromise(pendding)) {
-                        pendding.then(function (cx) {
-                            return function (arg) {
-                                results[cx] = arg;
-                                if (++resolved_count === dx) {
-                                    ok(results);
-                                }
-                            };
-                        }(cx));
-                        pendding.catch(function (e) {
-                            if (rejected_count++ === 0) {
-                                oh(e);
+            var resolved_count = 0,
+                results = Array(penddings.length);
+            for (var cx = 0, dx = penddings.length; cx < dx; cx++) {
+                var pendding = penddings[cx];
+                if (isThenable(pendding)) {
+                    pendding.then(function (cx) {
+                        return function (arg) {
+                            results[cx] = arg;
+                            if (++resolved_count === dx) {
+                                ok(results);
                             }
-                        });
-                    } else {
-                        results[cx] = pendding;
-                        if (++resolved_count === dx) {
-                            ok(results);
-                        }
-                    };
-                }
-            } catch (e) {
-                oh(e);
+                        };
+                    }(cx), oh);
+                } else {
+                    results[cx] = pendding;
+                    if (++resolved_count === dx) {
+                        ok(results);
+                    }
+                };
             }
         });
     };
     Promise.race = function (penddings) {
         return new Promise(function (ok, oh) {
-            try {
-                var resolved_count = 0,
-                    rejected_count = 0,
-                    results = Array(penddings.length);
-                for (var cx = 0, dx = penddings.length; cx < dx; cx++) {
-                    var pendding = penddings[cx];
-                    if (isPromise(pendding)) {
-                        pendding.then(function (cx) {
-                            return function (arg) {
-                                if (++resolved_count === 0) {
-                                    ok(arg);
-                                }
-                            };
-                        }(cx)).catch(function (e) {
-                            if (rejected_count++ === dx) {
-                                oh(e);
-                            }
-                        });
-                    } else {
-                        results[cx] = pendding;
-                    };
-                }
-            } catch (e) {
-                oh(e);
+            for (var cx = 0, dx = penddings.length; cx < dx; cx++) {
+                var pendding = penddings[cx];
+                if (isThenable(pendding)) {
+                    pendding.then(ok, oh);
+                } else {
+                    ok(pendding);
+                };
             }
         });
     };

package/coms/zimoli/appendChild.js

@@ -15,18 +15,9 @@ function _onappend(node, append = createEvent("append"), mount = createEvent("mo
     if (node.isMounted) return;
     if (node.nodeType === 1 || node.nodeType === 8) node.isMounted = true;
     dispatch(node, append);
-    var onappend = node.onappend;
-    if (isArray(onappend)) {
-        onappend.map(function (append_handler) {
-            append_handler.call(this, append);
-        }, node);
-    }
-    if (isFunction(onappend)) {
-        onappend.call(node, append);
-    }
-    var children = [].concat.apply([], node.childNodes);
-    if (children) for (var cx = 0, dx = children.length; cx < dx; cx++) {
-        _onappend(children[cx], append, mount);
+    var children = [...node.childNodes];
+    for (var c of children) {
+        _onappend(c, append, mount);
     }
     dispatch(node, mount);
 }
@@ -93,8 +84,7 @@ function insertAfter(alreadyMounted, obj, transition) {
         if (o.removeTimer) clearTimeout(o.removeTimer);
         _insertBefore.call(parent, o, alreadyMounted.nextSibling);
         o.with && insertBefore(alreadyMounted.nextSibling, o.with, transition);
-        if (isMounted(parent))
-            _onappend(o);
+        if (isMounted(parent)) _onappend(o);
         if (hasEnterStyle(o) && transition !== false) {
             isFunction(appendChild.transition) && appendChild.transition(o);
         }

package/coms/zimoli/cless.js

@@ -1,25 +1,31 @@
 
-function create(commFactory, className) {
+var _create = function (commFactory, className, _invoke) {
     if (!className) return commFactory;
     if (commFactory instanceof Promise) {
         return commFactory.then(function (result) {
-            return create(result, className);
+            return _invoke(result, className, _invoke);
         });
     }
     if (isFunction(commFactory)) {
         var result = function () {
             var commRelease = commFactory.apply(this || result, arguments);
             if (commRelease) {
-                commRelease = create(commRelease, className);
+                commRelease = _invoke(commRelease, className, _invoke);
             }
             return commRelease;
         };
         result.prototype = commFactory.prototype;
         commFactory.className = className;
         keys(commFactory).map(k => result[k] = commFactory[k]);
+        result.call = function (context, ...args) {
+            if (!isEmpty(context)) var release = commFactory.apply(context, args);
+            else release = commFactory.apply(result, args);
+            if (release) release = _invoke(release, className, _invoke);
+            return release;
+        };
         if ({}.hasOwnProperty.call(commFactory, 'toString')) {
             result.toString = function () {
-                return create(commFactory.toString(), className);
+                return _invoke(commFactory.toString(), className, _invoke);
             };
         }
         return result;
@@ -54,5 +60,5 @@ function cless(commFactory, innerCss, className) {
         }
         appendChild(head, stylesheet);
     }
-    return create(commFactory, className);
+    return _create(commFactory, className, _create);
 }

package/coms/zimoli/color.js

@@ -381,7 +381,6 @@ extend(color, {
 	},
 	rgb2h,
 	rgb4h,
-	rgb4s,
 	rgb2v,
 	rgb4v,
 	rgb2s,

package/coms/zimoli/compile.js

@@ -1 +1,64 @@
-"use ../compile/compile.js"
+"use strict";
+var Scanner = function (dataString, syntax) {
+    this.source = dataString;
+    this.syntax = syntax.syntax;
+    this.entry = syntax.entry;
+    var Token = this.token = syntax.token;
+    var block = this.block = new Token(syntax.entry, 0);
+    block.scanner = this;
+    this.blocks = this.block.children = [];
+    this.source = dataString;
+}
+Scanner.prototype = {
+    scan(index = 0, type = this.entry, collection = this.blocks, parent = this.block) {
+        var regInfo = this.syntax[type];
+        var dataString = this.source;
+        var Block = this.token;
+        if (!regInfo) return index;
+        if (!(regInfo instanceof Array)) {
+            regInfo = [regInfo];
+        }
+        var reg = regInfo[0];
+        loop: while (index < dataString.length) {
+            reg.lastIndex = index;
+            var res = reg.exec(dataString, collection);
+            if (res) {
+                index = reg.lastIndex;
+                var inc = 0;
+                while (res[++inc] === undefined) {
+                    if (inc >= regInfo.length) break loop;
+                }
+                var matchType = regInfo[inc];
+                if (!matchType) continue;
+                var savedIndex = reg.lastIndex - res[inc].length;
+                var children = [];
+                var block = new Block(matchType, savedIndex);
+                block.parent = parent;
+                block.children = children;
+                block.root = this.block;
+                block.scanner = this;
+                index = this.scan(index, matchType, children, block);
+                if (collection && savedIndex < index) {
+                    if (collection.length) {
+                        var lastChild = collection[collection.length - 1];
+                        block.prev = lastChild;
+                        lastChild.next = block;
+                    }
+                    collection.push(block);
+                }
+                block.end = index;
+            } else if (/y/.test(reg.flags)) {
+                throw new Error(`unexcepted token ${dataString[index]}`);
+            } else {
+                index = dataString.length;
+            }
+        }
+        return index;
+    }
+}
+var scan = function (data, syntax) {
+    var scanner = new Scanner(data, syntax);
+    scanner.scan();
+    return scanner.blocks;
+};
+module.exports = scan;

package/coms/zimoli/cross.js

@@ -20,7 +20,7 @@ if (cookiesData) {
 var digest = function () {
     dispatch('render', window);
 };
-
+if (/Trident/i.test(navigator.userAgent)) digest = lazy(digest, 60);
 var cross = cross_.bind(function (callback, onerror) {
     var xhr = new XMLHttpRequest;
     var abort = xhr.abort;

package/coms/zimoli/data.js

@@ -268,8 +268,7 @@ function parseConfig(api) {
     var required = [];
     var prepared = [];
     var autotrim = false;
-
-    id = id.replace(/[\?\|\:;](.+?)$/, function (m, s) {
+    id = id.replace(/[\?\|\:;](.*?)$/, function (m, s) {
         autotrim = /^[\|;]/.test(m);
         if (/^[\|\/]/.test(s)) autotrim = true, s = s.slice(1);
         s = s.split('&');
@@ -323,9 +322,13 @@ var parseData = function (sourceText) {
             sourceText = sourceText
                 .replace(/<!--[\s\S]*?-->|<\[CDATA\[[\s\S]*?\]\]>/ig, '')
                 .replace(/^[\s\S]*?<html>([\s\S]*)<\/html>[\s\S]*?$/i, '$1')
-                .replace(/^[\s\S]*?<body>([\s\S]*?)$/i, '$1')
+                .replace(/^([\s\S]*?)<body>([\s\S]*?)$/i, '$1<body>$2')
                 .replace(/<\/body>[\s\S]*?$/, '');
-            doc.body.innerHTML = sourceText;
+            var div = document.createElement('div');
+            div.innerHTML = sourceText.replace(/^([\s\S]*?)<body>[\s\S]*?$/, "$1")
+                .replace(/<head>/i, '').replace(/<\/head>/i, '');
+            for (var c of [...div.childNodes]) doc.head.appendChild(c);
+            doc.body.innerHTML = sourceText.replace(/^[\s\S]*?<body>/, '');
         } else {
             doc.documentElement.innerHTML = sourceText;
         }
@@ -705,6 +708,13 @@ var data = {
         data = this.parseConfig(data);
         configPormise = Promise.resolve(data);
     },
+    async addConfig(data) {
+        var p = configPormise;
+        var c = await p;
+        if (p !== configPormise) return;
+        data = this.parseConfig(data);
+        extend(c, data);
+    },
     getConfig() {
         return privates.getConfigPromise();
     },

package/coms/zimoli/dispatch.js

@@ -1,6 +1,6 @@
 var dispatch = "dispatchEvent" in document ? function dispatchEvent(target, event) {
     return target.dispatchEvent(event);
-} : function fireEvent(target, event) {
+} : function (target, event) {
     var fire = "on" + event.type;
     try {
         return target.fireEvent(fire, event);

package/coms/zimoli/input.js

@@ -67,10 +67,12 @@ var number = function (event) {
     }
 };
 var toFixed = function () {
-    if (this.value && this.fixed) var fixed = BigNumber.fix(this.value, this.fixed);
-    if (this.value !== fixed) {
-        this.value = fixed;
-        dispatch(this, 'change');
+    if (this.value && this.fixed) {
+        var fixed = BigNumber.fix(this.value, this.fixed);
+        if (this.value !== fixed) {
+            this.value = fixed;
+            dispatch(this, 'change');
+        }
     }
 };
 var positiveReg = /^\+|^positive\-?|\-?positive$|\+$/i;