efront 3.9.16 → 3.10.7

package/apps/pivot/api.yml

@@ -9,3 +9,4 @@
   params: options ::params-:key
   invoke: options ::invoke-:key?:params
   version: options ::version
+  uptime: options ::uptime

package/apps/pivot/home/welcome.html

@@ -20,4 +20,9 @@
     <padding>
         服务器版本&nbsp;&nbsp;<span -text="String(version)"></span>
     </padding>
-</block>
+</block>
+<block>
+    <padding>
+        启动时间&nbsp;&nbsp;<span -text="filterTime(hrtime)"></span>
+    </padding>
+</block>

package/apps/pivot/home/welcome.js

@@ -4,6 +4,8 @@ function main() {
     renderWithDefaults(page, {
         status: [],
         version: data.from("version"),
+        hrtime: data.from("uptime", a => Date.now() - a * 1000),
+        filterTime,
         async run(id, target) {
             target.setAttribute('pending', '')
             try {

package/coms/basic/FormData.js

@@ -0,0 +1,14 @@
+var FormData = this.FormData;
+if (!FormData) {
+    FormData = function FormData() {
+        this.form = {};
+    }
+
+    FormData.prototype.append = function (key, value) {
+        this.form[key] = value;
+    };
+
+    FormData.prototype.toString = function () {
+        return serialize(this.form);
+    };
+}

package/coms/basic/_cross.js

@@ -0,0 +1,329 @@
+var { getCookies, addCookie } = cookie;
+var { File } = this;
+function isFile(a) {
+    if (File) {
+        return a instanceof File;
+    }
+}
+var base = null, location_href = null;
+//               /////  1   ////////// 2 /////// 3 ////    4  //
+var domainReg = /^(?:(https?)\:)?\/\/(.*?)(?:\/(.*?))?([\?#].*)?$/i;
+var setHost = function (host) {
+    base = host;
+};
+var HeadersKeys = ["Content-Type"];
+var cors_hosts = [];
+function getDomainPath(url) {
+    return url.replace(domainReg, "$2/$3");
+}
+function getRequestProtocol(url) {
+    if (/^https:/i.test(url)) {
+        return "https:";
+    }
+    return "http:";
+}
+function isChildPath(relative, path) {
+    return relative.replace(/^(.*\/)[^\/]*$/, path);
+}
+
+var getCrossUrl = function (domain, headers) {
+    if (notCross(domain)) return domain;
+    var originDomain = getDomainPath(domain);
+    var _cookies = getCookies(originDomain);
+    var _headers = {};
+    if (_cookies) {
+        _headers.Cookie = _cookies;
+    }
+    extend(_headers, headers);
+    _headers = serialize(_headers);
+    if (_headers) _headers = "," + _headers;
+    return domain
+        .replace(/^(s?)(\/\/)/i, "http$1:$2")
+        .replace(domainReg, base + `*${/^(https\:|s\/\/)/i.test(domain) ? "*" : ""}$2${_headers}/$3$4`);
+};
+function noop() { }
+function toResponse() {
+    if (this.responseType === 'json') return JSON.stringify(this.response);
+    return this.response;
+}
+function _cross(jsonp, digest = noop, method, url, headers) {
+    var originDomain = getDomainPath(url);
+    if (!originDomain) throw new Error("路径格式错误！");
+    var _cookies = getCookies(originDomain);
+    var _headers = {};
+    if (_cookies) {
+        _headers.Cookie = _cookies;
+    }
+    extend(_headers, headers);
+    if (/^[mc]/i.test(method)) {
+        _headers["User-Agent"] = /^m/i.test(method)
+            ? "Efront/1.9 (iPhone) Safari/602.1"
+            : "Efront/1.9 (Windows) Chrome/77.0.3865.90";
+        method = method.slice(1);
+    }
+    var loaded, errored;
+    var onload = function (data) {
+        removeFromList(requests, xhr);
+        if (xhr.decoder) {
+            data = xhr.decoder(data);
+        }
+        loaded = data;
+        flush();
+        digest();
+    };
+    var onerror1 = function (e) {
+        removeFromList(requests, xhr);
+        errored = e || "未知错误！";
+        flush();
+        digest();
+    };
+    var onerror = async function (e) {
+        if (e.type === 'error') {
+            e = { response: "无法访问服务器", toString: toResponse };
+        }
+        for (var r of reforms) {
+            var r = await reform(r, { method, url, status: xhr.status, headers: _headers }, fire, onerror1, e);
+            if (r === false) return;
+        }
+        onerror1(e);
+    };
+    var flush = function () {
+        var then = xhr.then;
+        delete xhr.then;
+        if (loaded) onloads.splice(0, onloads.length).map(e => e instanceof Function && e(xhr));
+        if (errored) onerrors.splice(0, onerrors.length).map(e => e instanceof Function && e(errored));
+        xhr.then = then;
+    };
+    if (/^jsonp/i.test(method)) {
+        var cb = method.split('\-')[1] || 'callback';
+        setTimeout(function () {
+            if (!isEmpty(jsondata) && isEmpty(datas)) {
+                datas = serialize(jsondata);
+            }
+            if (datas) {
+                xhr.src += (/\?/.test(xhr.src) ? "&" : "?") + datas;
+            }
+        });
+        var xhr = jsonp(url, {
+            [cb](a) {
+                onload({ status: 200, response: JSON.stringify(a), toString: toResponse });
+            }
+        });
+        xhr.onerror = onerror;
+    }
+    else {
+        var nocross = notCross(url);
+        var callback = function () {
+            var exposeHeaders = xhr.getResponseHeader("access-control-expose-headers");
+            var exposeMap = {};
+            if (exposeHeaders) exposeHeaders.split(",").forEach(h => exposeMap[h.toLowerCase()] = true);
+            if (xhr.getResponseHeader) {
+                var exposekey = nocross ? "set-cookie" : "efront-cookie";
+                if (exposeMap[exposekey]) {
+                    var cookie = xhr.getResponseHeader(exposekey);
+                    addCookie(cookie, originDomain);
+                }
+            }
+            switch (xhr.status) {
+                case 0:
+                    if (!xhr.response) {
+                        onerror({ status: 0, response: "无法访问服务器", toString: toResponse });
+                        break;
+                    }
+                case 200:
+                case 201:
+                case 304:
+                    onload(xhr);
+                    break;
+                case 307:
+                case 302:
+                case 301:
+                    if (xhr.isRedirected > 2) break;
+                    var exposekey = nocross ? "location" : "efront-location";
+                    var location = exposeMap[exposekey] && xhr.getResponseHeader(exposekey);
+                    if (!domainReg.test(location)) {
+                        if (/^\//.test(location)) {
+                            location = originDomain.replace(/\/.*$/, location);
+                        } else {
+                            location = originDomain.replace(/[^\/+]$/, location);
+                        }
+                        location = getRequestProtocol(url) + "//" + location;
+                    }
+                    var crs = _cross("get", location, _headers);
+                    crs.isRedirected = (xhr.isRedirected || 0) + 1;
+                    crs.done(onload, false);
+                    crs.error(onerror, false);
+                    break;
+                default:
+                    onerror(xhr);
+            }
+        };
+        var cross = this;
+        var xhr = cross(callback, onerror);
+        var send = xhr.send;
+        xhr.toString = toResponse;
+        xhr.json = xhr.data = xhr.send = function (data, value) {
+            if (!jsondata && !(isEmpty(data) && isEmpty(value))) jsondata = data instanceof Array ? [] : {};
+            if (FormData && data instanceof FormData) {
+                datas = data;
+            } else if (isObject(data) && !isFile(data)) {
+                extend(jsondata, data);
+            } else if (!isEmpty(value)) {
+                extend(jsondata, { [data]: value });
+            } else if (isString(data) && value !== false && /^\s*\{|\=/.test(data)) {
+                var data = /^\s*\{/.test(data) ? JSON.parse(data) : parseKV(data, "&", "=");
+                extend(jsondata, data);
+            } else {
+                datas = data;
+            }
+            return xhr;
+        };
+        xhr.form = function (data) {
+            xhr.data(data);
+            if (FormData) {
+                datas = new FormData;
+                for (var k in jsondata) {
+                    datas.append(k, jsondata[k]);
+                }
+            } else {
+                realHeaders["Content-Type"] = "application/x-www-form-urlencoded";
+                datas = serialize(jsondata, "&", "=");
+            }
+        };
+
+        var fire = function () {
+            var isform = /^f/i.test(method);
+            if (isform) {
+                if (method === 'form') method = 'post';
+                else method = method.slice(1);
+            }
+            if (/^jsonp/i.test(method)) method = "get";
+            if (!isEmpty(jsondata) && isEmpty(datas)) {
+                if (/^(get|head|trace)$/i.test(method)) {
+                    url = url.replace(/#[\s\S]*/, '');
+                    datas = serialize(jsondata);
+                    if (datas) {
+                        url += (/\?/.test(url) ? "&" : "?") + datas;
+                        datas = "";
+                    }
+
+                } else if (isform) {
+                    xhr.form(jsondata);
+                } else {
+                    datas = JSON.stringify(jsondata);
+                    if (datas === "{}" || datas === "[]") {
+                        datas = '';
+                    } else {
+                        realHeaders["Content-Type"] = "application/json;charset=UTF-8";
+                    }
+                }
+            }
+            if (nocross) {
+                extend(realHeaders, _headers);
+                xhr.open(method, url);
+            } else {
+                xhr.open(method, getCrossUrl(url, _headers));
+            }
+            Object.keys(realHeaders).forEach(key => setRequestHeader.call(xhr, key, realHeaders[key]));
+            if (!isEmpty(datas)) send.call(xhr, datas);
+            else send.call(xhr);
+            digest();
+        };
+
+        setTimeout(fire, 0);
+
+    }
+    var setRequestHeader = xhr.setRequestHeader;
+    var realHeaders = Object.create(null);
+    xhr.setRequestHeader = function (key, value) {
+        realHeaders[key] = value;
+    };
+
+    var onloads = [], onerrors = [];
+    xhr.done = xhr.success = function (on, asqueue = true) {
+        if (!asqueue) onloads.splice(0, onloads.length);
+        onloads.push(on);
+        flush();
+        return xhr;
+    };
+    var datas = "";
+    var jsondata = null;
+    xhr.fail = xhr.error = function (on, asqueue = true) {
+        if (!asqueue) {
+            onerrors.splice(0, onerrors.length);
+        }
+        onerrors.push(on);
+        flush();
+        return xhr;
+    };
+    xhr.then = function (ok, oh) {
+        onloads.push(ok);
+        onerrors.push(oh);
+        flush();
+    };
+    var abort = xhr.abort;
+    xhr.abort = function () {
+        removeFromList(requests, this);
+        if (isFunction(abort)) abort.call(this);
+    };
+    requests.push(xhr);
+    return xhr;
+}
+function addDirect(a) {
+    if (cors_hosts.indexOf(a) >= 0) return;
+    if (typeof a === 'string' || a instanceof RegExp) cors_hosts.push(a);
+}
+function notCross(domain) {
+    if (!base || location_href && location_href === domain.slice(0, location_href.length) || !/^https?\:\/\/|^s?\/\//.test(domain)) return true;
+    for (var cx = 0, dx = cors_hosts.length; cx < dx; cx++) {
+        var host = cors_hosts[cx];
+        if (host instanceof RegExp) {
+            if (host.test(domain)) return true;
+        } else {
+            host = host.replace(domainReg, '$2/$3');
+            if (domain.replace(domainReg, '$2/$3').slice(0, host.length) === host) return true;
+        }
+    }
+    return false;
+}
+
+var requests = [];
+var reforms = [];
+function reform(r, info, fire, cancel, e) {
+    var fired = false;
+    return r(info, function () {
+        if (fired) return;
+        fired = true;
+        fire();
+    }, function () {
+        if (fired) return;
+        fired = true;
+        cancel(e);
+    })
+}
+function addReform(r) {
+    if (isFunction(r)) reforms.push(r);
+}
+var bind = _cross.bind;
+_cross.bind = function () {
+    var _cross = bind.apply(this, arguments);
+    extend(_cross, {
+        requests,
+        abortAll() {
+            var rs = requests.splice(0, requests.length);
+            for (var r of rs) r.abort();
+        },
+        setHost,
+        addReform,
+        getCookies,
+        addCookie,
+        addDirect,
+        getCrossUrl
+    });
+    return _cross;
+}
+_cross.setHost = setHost;
+_cross.setLocation = function (host) {
+    location_href = host;
+    if (!base) base = /^https?\:/i.test(location_href) ? '/' : "http://efront.cc/";
+};

package/coms/basic/cookie.js

@@ -24,6 +24,7 @@ var parseCookieFromText = function (cookie) {
 
 function addCookie(cookie_text, originDomain = "") {
     if (!cookie_text) return;
+    if (cookie_text instanceof Array) cookie_text = cookie_text.join(",");
     var cookies = cookie_text.replace(/(^|;|,)\s*(expires)=(\w*),([^=]*)(;|$)/ig, "$1$2=$3.$4$5")
         .split(/,\s*/).map(parseCookieFromText);
     for (var cookie of cookies) {

package/coms/basic/parseURL_test.js

@@ -42,4 +42,5 @@ test(":cluster-opt.html", "pathname", ":cluster-opt.html")
 test("d:/cluster-opt.html", "pathname", "d:/cluster-opt.html")
 test("d:\\cluster-opt.html", "pathname", "d:\\cluster-opt.html")
 test("ftp:\\\\cluster-opt.html", "host", "cluster-opt.html")
-test("\\\\cluster-opt.html", "host", "cluster-opt.html")
+test("\\\\cluster-opt.html", "host", "cluster-opt.html")
+test("https://a:b@測試?abc#foo", "host", "測試")

package/coms/compile/common.js

@@ -167,6 +167,9 @@ var createScoped = function (parsed) {
                 case STRAP:
                     var s = o.text;
                     switch (s) {
+                        case "return":
+                            funcbody.return = true;
+                            break;
                         case "await":
                             funcbody.async = funcbody.await = true;
                             break;

package/coms/compile/scanner2.js

@@ -374,6 +374,9 @@ class Program extends Array {
     get await() {
         return this.scoped.await;
     }
+    get return() {
+        return this.scoped.return;
+    }
     get scoped() {
         if (this._scoped) return this._scoped;
         return this._scoped = createScoped(this);

package/coms/reptile/cross.js

@@ -0,0 +1,109 @@
+return _cross.bind(function (callback, onerror) {
+    var response, responseObject, responseType = "", error;
+    var xhr = {
+        status: 0,
+        readyState: 0,
+        method: null,
+        url: null,
+        http: null,
+        headers: {},
+        responseHeaders: {},
+        get response() {
+            if (responseType === "" || responseType === "text") {
+                if (this.readyState !== 4) return '';
+                return String(response);
+            }
+            else if (error) return null;
+            if (responseObject !== null) return responseObject;
+            switch (responseType) {
+                case "arraybuffer":
+                    return response.buffer;
+                case "json":
+                    if (!response) return null;
+                    responseObject = JSON.parse(String(response));
+                    return responseObject;
+            }
+            return responseObject;
+
+        },
+        set response(v) {
+            response = v;
+        },
+        getResponseHeader(key) {
+            key = String(key).toLowerCase();
+            if (this.responseHeaders[key]) return this.responseHeaders[key];
+            if (key === "access-control-expose-headers") {
+                return 'set-cookie,location';
+            }
+            return null;
+        },
+        send(data) {
+            var { hostname, port, path, auth } = parseURL(this.url);
+            if (data instanceof FormData) data = String(data);
+            if (data) {
+                data = Buffer.from(data);
+                this.headers["Content-Length"] = data.length;
+            }
+            var req = http.request({
+                method: this.method,
+                hostname,
+                port,
+                path,
+                auth,
+                headers: this.headers,
+            }, function (res) {
+                var data = [];
+                xhr.status = res.statusCode;
+                xhr.responseHeaders = res.headers;
+                res.on("data", function (chunk) {
+                    xhr.readyState = 4;
+                    data.push(chunk);
+                });
+                res.on("end", function () {
+                    response = Buffer.concat(data);
+                    xhr.readyState = 4;
+                    callback();
+                });
+                res.on("error", function (e) {
+                    xhr.readyState = 4;
+                    error = e;
+                    onerror(e);
+                });
+                this.readyState = 2;
+            });
+            this.readyState = 1;
+            if (data) req.end(data);
+            else req.end();
+        },
+        open(method, url) {
+            this.method = method;
+            this.url = url;
+            this.status = 0;
+            this.readyState = 0;
+            response = null;
+            responseObject = null;
+            error = null;
+            var http;
+            if (/^https?\:/i.test(url)) {
+                http = require("http");
+            }
+            else {
+                http = require("https");
+            }
+            this.http = http;
+        },
+        get responseType() {
+            return responseType;
+        },
+        set responseType(v) {
+            if (v === "document") return;
+            if (this.status !== 0) throw new Error("状态错误");
+            responseType = v;
+        },
+        setRequestHeader(key, value) {
+            this.headers[key] = value;
+        },
+
+    };
+    return xhr;
+}, null, undefined);

package/coms/reptile/m3u8Download.js

@@ -23,7 +23,7 @@ function main(m3u8, dst) {
             console.info(file);
             var fileurl = URL.resolve(m3u8, file);
             return fetch(fileurl).then(function (buff) {
-                return fs(path.join(dst, index(cx, list.length) + '.' + file)).writeSync(buff);
+                return fs2(path.join(dst, index(cx, list.length) + '.' + file)).writeSync(buff);
             });
         });
     });

package/coms/zimoli/color.js

@@ -254,13 +254,15 @@ function stringify(color) {
 	}
 }
 function doWith(manager, color, args) {
-	var c = parse(color);
+	var isparsed = color instanceof Array,
+		c = isparsed ? color : parse(color);
 	if (!c) {
 		console.warn(`颜色数据不正确:${color}`);
 		return color;
 	}
 	c = manager(c, args);
-	return stringify(c);
+	if (!isparsed) c = stringify(c);
+	return c;
 }
 
 function normal([r, g, b]) {