efront 3.20.2 → 3.20.6

package/apps/pivot/menu.yml

@@ -5,15 +5,11 @@ WEB:
   文件管理: /wow/root
   长连接管理: /link/index
   字典: /dict/list
-  接口: /api/list
 任务:
   密钥管理: /token/list
   任务建立: /task/list
   定期执行: /tick/list
   # 服务器: /api/host
-用户:
-  账号列表: /user/list
-  标签管理: /user/tag/list
 服务器日志:
   访问计数: /log/count
   启动记录: /log/boot

package/coms/basic/Matrix.js

@@ -0,0 +1,424 @@
+var notMatchLength = new Error("矩阵长度不一致");
+class Matrix extends Array {
+    static create2d(theta = 0) {
+        return MatrixTransposed.matrix2d(theta);
+    }
+    static create3d(factor = [0, 0, 0]) {
+        return MathMatrix.matrix3d(factor);
+    }
+    size() {
+        return size(this);
+    }
+    dirty() {
+        this._invert = null;
+    }
+    _invert = null;
+    get invert() {
+        if (this._invert) return this._invert;
+        return this._invert = this.slice().inverse();
+    }
+    transpose() {
+        if (this.constructor === MathMatrix) {
+            var m = new MatrixTransposed;
+        }
+        else {
+            var m = new MathMatrix;
+        }
+        m.push.apply(m, this);
+        m.transpose_();
+        return m;
+    }
+    transpose_() {
+        var [size] = this.size();
+        for (var cx = 0, dx = size; cx < dx; cx++) {
+            for (var cy = cx + 1, dy = dx; cy < dy; cy++) {
+                var i = cx * size + cy;
+                var j = cy * size + cx;
+                var tmp = this[i];
+                this[i] = this[j];
+                this[j] = tmp;
+            }
+        }
+        return this;
+    }
+    inverse() {
+        this.dirty();
+        return this.constructor.逆(this);
+    }
+    rotate(factor, center) {
+        this.dirty();
+        if (center) this.translate(center.map(负));
+        if (factor.length) {
+            this.multiply(this.constructor.matrix3d(factor));
+        }
+        else {
+            this.multiply(this.constructor.matrix2d(factor));
+        }
+        if (center) this.translate(center);
+        return this;
+    }
+    translate(vector) {
+        this.dirty();
+        return this.constructor.translate(this, vector);
+    }
+    scale(ratio, center) {
+        this.dirty();
+        if (center) this.translate(center.map(负));
+        times(this, ratio);
+        if (center) this.translate(center);
+        this[this.length - 1] = 1;
+        return this;
+    }
+    multiply(a) {
+        this.dirty();
+        return this.constructor.multiply(this, a);
+    }
+    transform(dots) {
+        if (dots instanceof Array) return this.constructor.transform(this, dots);
+        if (arguments.length > 1) {
+            var a = Array.prototype.slice.apply(arguments, 0);
+            return this.constructor.transform(this, a);
+        }
+        return dots;
+    }
+}
+class MathMatrix extends Matrix {
+
+    static transform(B, dots) {
+        var dimention = Math.sqrt(B.length - 1) | 0;
+        if (dots.length % dimention !== 0) throw notMatchLength;
+        if (dots === B) B = B.slice(0);
+        var ds = dots.slice(0);
+        var dim2 = B.length % dimention !== 0 ? dimention + 1 : dimention;
+        for (var cx = 0, dx = dots.length; cx < dx; cx += dimention) {
+            for (var cy = 0, dy = dimention; cy < dy; cy++) {
+                var sum = 0;
+                for (var ct = 0, dt = dimention; ct < dt; ct++) {
+                    sum += ds[cx + ct] * B[ct * dim2 + cy];
+                }
+                sum += B[dimention * dim2 + cy];
+                dots[cx + cy] = sum;
+            }
+        }
+        return dots;
+    };
+
+
+    static translate(A, delta) {
+        var [dim2, dim] = size(A);
+        var inc = 0;
+        for (var cx = dim * dim2, dx = cx + dim; cx < dx; cx++) {
+            A[cx] = (A[cx] || 0) + delta[inc++];
+        }
+        return A;
+    }
+
+    static multiply(A, B) {
+        if (A.length !== B.length) throw notMatchLength;
+        var dim = Math.sqrt(A.length) | 0;
+        if (dim * dim !== A.length) throw notMatchLength;
+        var X = A.slice(0);
+        for (var cx = 0, dx = A.length; cx < dx; cx += dim) {
+            for (var cy = 0, dy = dim; cy < dy; cy++) {
+                var sum = 0;
+                for (var ct = 0, dt = dim; ct < dt; ct++) {
+                    sum += X[cx + ct] * B[ct * dim + cy];
+                }
+                A[cx + cy] = sum;
+            }
+        }
+        return A;
+    }
+
+
+    static matrix2d(theta) {
+        var cosa = Math.cos(theta);
+        var sina = Math.sin(theta);
+        return new MathMatrix(
+            cosa, sina, 0,
+            -sina, cosa, 0,
+            0, 0, 1
+        );
+    };
+
+    static matrix3d(factor) {
+        var n = norm(factor.slice(0, 3));
+        var theta = factor.length === 4 ? factor[3] : n;
+        var vec = times(factor, 1 / n);
+        var cosa = Math.cos(theta);
+        var sina = Math.sin(theta);
+        var vera = 1 - cosa;
+        var [x_u, y_u, z_u] = !n ? [0, 0, 1] : vec;
+        return new MathMatrix(
+            cosa + x_u * x_u * vera, x_u * y_u * vera - z_u * sina, x_u * z_u * vera + y_u * sina, 0,
+            x_u * y_u * vera + z_u * sina, cosa + y_u * y_u * vera, y_u * z_u * vera - x_u * sina, 0,
+            x_u * z_u * vera - y_u * sina, y_u * z_u * vera + x_u * sina, cosa + z_u * z_u * vera, 0,
+            0, 0, 0, 1
+        );
+    }
+
+    static 逆 = function (A) {
+        var dim = Math.sqrt(A.length) | 0;
+        if (dim * dim !== A.length) throw notMatchLength;
+        var E = new Array(A.length).fill(0);
+        for (var cx = 0, dx = dim; cx < dx; cx++)E[cx * dim + cx] = 1;
+        var X = A.splice(0, A.length);
+        A.push.apply(A, E);
+        for (var cx = 0, dx = dim; cx < dx; cx++) {
+            var start = cx * dim + cx;
+            var max_ct, v = 0;
+            for (var ct = start, dt = X.length; ct < dt; ct += dim) {
+                var v0 = Math.abs(X[ct]);
+                if (v0 > v) {
+                    max_ct = ct;
+                    v = v0;
+                }
+            }
+            ct = max_ct;
+            if (ct !== start) {
+                var delta = ct - start;
+                var ratio = (1 - X[start]) / X[ct];
+                for (var cy = cx * dim, dy = cy + dim; cy < dy; cy++) {
+                    X[cy] += X[cy + delta] * ratio;
+                    A[cy] += A[cy + delta] * ratio;
+                }
+            }
+            if (X[start] !== 1) {
+                var ratio = 1 / X[start];
+                for (var cy = cx * dim, dy = cy + dim; cy < dy; cy++) {
+                    X[cy] *= ratio;
+                    A[cy] *= ratio;
+                }
+            }
+            for (var ct = start + dim, dt = X.length; ct < dt; ct += dim) {
+                if (X[ct] === 0) continue;
+                var ratio = -X[ct];
+                var delta = start - ct;
+                for (var cy = ct - cx, dy = cy + dim; cy < dy; cy++) {
+                    X[cy] += X[cy + delta] * ratio;
+                    A[cy] += A[cy + delta] * ratio;
+                }
+            }
+        }
+        for (var cx = dim - 1; cx > 0; cx--) {
+            var start = cx * dim + cx;
+            for (var ct = start - dim; ct >= 0; ct -= dim) {
+                if (X[ct] === 0) continue;
+                var ratio = -X[ct];
+                var delta = start - ct;
+                for (var cy = ct - cx, dy = cy + dim; cy < dy; cy++) {
+                    X[cy] += X[cy + delta] * ratio;
+                    A[cy] += A[cy + delta] * ratio;
+                }
+            }
+        }
+        return A;
+    };
+
+}
+class MatrixTransposed extends Matrix {
+    static transform(B, dots) {
+        var dimention = Math.sqrt(B.length - 1) | 0;
+        if (dots.length % dimention !== 0) throw notMatchLength;
+        if (dots === B) B = B.slice(0);
+        var ds = dots.slice(0);
+        var dim2 = B.length % dimention !== 0 ? dimention + 1 : dimention;
+        for (var cx = 0, dx = dots.length; cx < dx; cx += dimention) {
+            for (var cy = 0, dy = dimention; cy < dy; cy++) {
+                var sum = 0;
+                var start = dim2 * cy;
+                for (var ct = 0, dt = dimention; ct < dt; ct++) {
+                    sum += ds[cx + ct] * B[start + ct];
+                }
+                sum += B[start + dimention];
+                dots[cx + cy] = sum;
+            }
+        }
+        return dots;
+    };
+
+    static translate(A, delta) {
+        var [dim2, dim] = size(A);
+        var inc = 0;
+        for (var cx = dim, dx = dim * dim2; cx < dx; cx += dim2) {
+            A[cx] = (A[cx] || 0) + delta[inc++];
+        }
+        return A;
+    }
+
+    static multiply(A, B) {
+        if (A.length !== B.length) throw notMatchLength;
+        var dim = Math.sqrt(A.length) | 0;
+        if (dim * dim !== A.length) throw notMatchLength;
+        var X = A.slice(0);
+        for (var cx = 0, dx = A.length; cx < dx; cx += dim) {
+            for (var cy = 0, dy = dim; cy < dy; cy++) {
+                var sum = 0;
+                for (var ct = 0, dt = dim; ct < dt; ct++) {
+                    sum += B[cx + ct] * X[ct * dim + cy];
+                }
+                A[cx + cy] = sum;
+            }
+        }
+        return A;
+    }
+
+    static matrix2d(theta) {
+        var cosa = Math.cos(theta);
+        var sina = Math.sin(theta);
+        return new MatrixTransposed(
+            cosa, -sina, 0,
+            sina, cosa, 0,
+            0, 0, 1
+        );
+    }
+
+    static matrix3d(factor) {
+        var n = norm(factor.slice(0, 3));
+        var theta = factor.length === 4 ? factor[3] : n;
+        var vec = times(factor, 1 / n);
+        var cosa = Math.cos(theta);
+        var sina = Math.sin(theta);
+        var vera = 1 - cosa;
+        var [x_u, y_u, z_u] = !n ? [0, 0, 1] : vec;
+        return new MatrixTransposed(
+            cosa + x_u * x_u * vera, x_u * y_u * vera + z_u * sina, x_u * z_u * vera - y_u * sina, 0,
+            x_u * y_u * vera - z_u * sina, cosa + y_u * y_u * vera, y_u * z_u * vera + x_u * sina, 0,
+            x_u * z_u * vera + y_u * sina, y_u * z_u * vera - x_u * sina, cosa + z_u * z_u * vera, 0,
+            0, 0, 0, 1
+        );
+    }
+    static 逆 = function (A) {
+        var dim = Math.sqrt(A.length) | 0;
+        if (dim * dim !== A.length) throw notMatchLength;
+        var E = new Array(A.length).fill(0);
+        for (var cx = 0, dx = dim; cx < dx; cx++)E[cx * dim + cx] = 1;
+        var X = A.splice(0, A.length);
+        A.push.apply(A, E);
+        for (var cx = 0, dx = dim; cx < dx; cx++) {
+            var start = cx * dim + cx;
+            var max_ct, v = 0;
+            for (var ct = start, dt = cx * dim + dim; ct < dt; ct++) {
+                var v0 = Math.abs(X[ct]);
+                if (v0 > v) {
+                    max_ct = ct;
+                    v = v0;
+                }
+            }
+            ct = max_ct;
+            if (ct !== start) {
+                var delta = ct - start;
+                var ratio = (1 - X[start]) / X[ct];
+                for (var cy = cx, dy = X.length; cy < dy; cy += dim) {
+                    X[cy] += X[cy + delta] * ratio;
+                    A[cy] += A[cy + delta] * ratio;
+                }
+            }
+            if (X[start] !== 1) {
+                var ratio = 1 / X[start];
+                for (var cy = cx, dy = X.length; cy < dy; cy += dim) {
+                    X[cy] *= ratio;
+                    A[cy] *= ratio;
+                }
+            }
+            for (var ct = start + 1, dt = start + dim - cx; ct < dt; ct++) {
+                if (X[ct] === 0) continue;
+                var ratio = -X[ct];
+                var delta = start - ct;
+                for (var cy = cx + ct - start, dy = X.length; cy < dy; cy += dim) {
+                    X[cy] += X[cy + delta] * ratio;
+                    A[cy] += A[cy + delta] * ratio;
+                }
+            }
+        }
+        for (var cx = dim - 1; cx >= 0; cx--) {
+            var start = cx * dim + cx;
+            for (var ct = start - 1, dt = start - cx; ct >= dt; ct--) {
+                if (X[ct] === 0) continue;
+                var ratio = -X[ct];
+                var delta = start - ct;
+                for (var cy = cx + ct - start, dy = X.length; cy < dy; cy += dim) {
+                    X[cy] += X[cy + delta] * ratio;
+                    A[cy] += A[cy + delta] * ratio;
+                }
+            }
+        }
+        return A;
+    };
+
+}
+Matrix.MathMatrix = MathMatrix;
+Matrix.MatrixTransposed = MatrixTransposed;
+
+
+function inner(vec1, vec2) {
+    if (vec1.length !== vec2.length) throw notMatchLength;
+    var sum = 0;
+    for (var cx = 0, dx = vec1.length; cx < dx; cx++) {
+        sum += vec1[cx] * vec2[cx];
+    }
+    return sum;
+}
+
+function cross2(vec1, vec2) {
+    var [x1, y1] = vec1;
+    var [x2, y2] = vec2;
+    return x1 * y2 - x2 * y1;
+}
+function cross3(vec1, vec2) {
+    var [x1, y1, z1] = vec1;
+    var [x2, y2, z2] = vec2;
+    return [y1 * z2 - y2 * z1, z1 * x2 - z2 * x1, x1 * y2 - x2 * y1];
+}
+function cross(vec1, vec2) {
+    if (vec1.length !== vec2.length) throw notMatchLength;
+    if (vec1.length === 2) return cross2(vec1, vec2);
+    if (vec1.length === 3) return cross3(vec1, vec2);
+    throw new Error("向量维度不支持！");
+}
+function 负(a) {
+    return -a;
+}
+function times(vector, factor) {
+    for (var cx = 0, dx = vector.length; cx < dx; cx++) {
+        vector[cx] *= factor;
+    }
+    return vector;
+}
+
+var norm = function (vector) {
+    var sum = 0;
+    for (var cx = 0, dx = vector.length; cx < dx; cx++) {
+        sum += vector[cx] * vector[cx];
+    }
+    return Math.sqrt(sum);
+};
+
+
+function size(A) {
+    var dim = Math.sqrt(A.length - 1) | 0;
+    var dim2 = dim;
+    if (A.length % dim !== 0) {
+        dim2++;
+    }
+    if ((dim + 1) * dim2 !== A.length) throw notMatchLength;
+    return [dim2, dim];
+}
+
+
+function olinde(v, vector) {
+    // 罗德里格旋转公式
+    // https://baike.baidu.com/item/%E7%BD%97%E5%BE%B7%E9%87%8C%E6%A0%BC%E6%97%8B%E8%BD%AC%E5%85%AC%E5%BC%8F/18878562
+    // https://www.cnblogs.com/flyinggod/p/8144100.html 旋转矩阵、欧拉角、四元数理论及其转换关系
+    var theta = norm(vector);
+    var k = times(vector.slice(0), 1 / theta);
+    var cosa = Math.cos(theta);
+    var sina = Math.sin(theta);
+    var inna = inner(k, v);
+    var aa = inna * (1 - cosa);
+    var kv = cross(k, v);
+    for (var cx = 0, dx = k.length; cx < dx; cx++) {
+        v[cx] = v[cx] * cosa + aa * k[cx] + sina * kv[cx];
+    }
+    return v;
+}

package/coms/basic/cookie.js

@@ -23,6 +23,7 @@ var parseCookieFromText = function (cookie) {
 };
 
 function addCookie(cookie_text, originDomain = "") {
+    originDomain = getDomainPath(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")
@@ -57,6 +58,7 @@ function addCookie(cookie_text, originDomain = "") {
 }
 
 function getCookies(domainPath) {
+    domainPath = getDomainPath(domainPath);
     var cookieObject = {};
     var splited = domainPath.split("/");
     var domain = splited[0];
@@ -87,10 +89,16 @@ function getCookies(domainPath) {
 }
 
 function delCookies(domainPath) {
+    domainPath = getDomainPath(domainPath);
     var splited = domainPath.split("/");
     var domain = splited[0];
     delete cookiesMap[domain];
 }
+function getDomainPath(url) {
+    var { host, pathname } = parseURL(url);
+    if (pathname) return host + pathname;
+    return host;
+}
 
 return {
     cookiesMap,

package/coms/basic/cross_.js

@@ -322,6 +322,9 @@ function cross_(jsonp, digest = noop, method, url, headers) {
         xhr.nocookie = true;
         return xhr;
     };
+    xhr.getCookies = function () {
+        return getCookies(originDomain);
+    };
     requests.push(xhr);
     return xhr;
 }

package/coms/basic/queue.js

@@ -42,7 +42,8 @@ function queue(list, count = 1, context = null) {
         if (!(count >= 1)) {
             count = 1;
         }
-        while (cx < count) {
+        if (list.length === 0) run();
+        else while (cx < count) {
             run();
         }
     });

package/coms/zimoli/confirm.less

@@ -8,7 +8,7 @@
     cursor: default;
     box-sizing: border-box;
     background-color: #fff;
-    border: 1px solid #0001;
+    border: 1px solid #999;
     box-shadow: 0 0 16px -6px rgba(0, 0, 0, .2);
 }
 

package/coms/zimoli/drag.js

@@ -128,6 +128,7 @@ var bindActionTarget = function (action, actionTarget) {
 };
 
 drag.on = function (target, actionTarget = target.dragTarget) {
+    if (getTargetIn(target, actionTarget, false)) [target, actionTarget] = [actionTarget, target];
     if (!actionTarget) {
         if (target.dragHandle) {
             actionTarget = target;

package/coms/zimoli/field.html

@@ -4,7 +4,7 @@
         <span class="required" ng-if="field.required">*</span>
     </div>
     <div class="body">
-        <model _data=data _field=field></model>
+        <model _data=data _field=field _readonly="readonly"></model>
         <span class="error" ng-bind="error"></span>
     </div>
     <div class="foot" ng-if="field.msg">
@@ -12,5 +12,5 @@
     </div>
 </template>
 <template v-else>
-    <model _data=data _field=field></model>
+    <model _data=data _field=field _readonly="readonly"></model>
 </template>

package/coms/zimoli/field.js

@@ -9,7 +9,8 @@ function main(elem) {
             model,
             data,
             error: null,
-            field: f
+            field: f,
+            readonly: !!this.readonly
         });
         elem.oldValue = data[f.key];
         elem.setAttribute("field", f.key);

package/coms/zimoli/matrix.js

@@ -0,0 +1 @@
+Matrix

package/coms/zimoli/menuList.js

@@ -312,6 +312,10 @@ function main(page, items, active, direction = 'y') {
         }`;
             var notHidden = `!${itemName}.hidden`;
             var generator = getGenerator(page, 'menu-item');
+            var fire0 = function () {
+                fire.apply(this, arguments);
+                dispatch(window, 'render');
+            };
             list(page, function (index) {
                 var item = items[index];
                 if (!item) return;
@@ -325,7 +329,7 @@ function main(page, items, active, direction = 'y') {
                 on("mouseenter")(a, open);
                 on("pointermove")(a, open);
                 if (istoolbar) on("pointerdown")(a, open1);
-                on("click")(a, fire);
+                on("click")(a, fire0);
                 return a;
             });
             on("append")(page, function () {
@@ -358,7 +362,7 @@ function main(page, items, active, direction = 'y') {
             on("mouseenter")(elem, open);
             on("pointermove")(elem, cancel);
             if (istoolbar) on("pointerdown")(elem, open1);
-            on("click")(elem, fire);
+            on("click")(elem, fire0);
             return elem;
         }, direction);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "efront",
-    "version": "3.20.2",
+    "version": "3.20.6",
     "description": "一个开发工具，开放源代码，自带组件库和编译环境，可以用来开发web组件，web应用或nodejs模块，或做为已有代码的加密工具，也可以做为静态页面服务器或跨域中转服务器使用",
     "main": "public/efront.js",
     "directories": {