efront 3.12.5 → 3.13.3

package/coms/zimoli/picture_.js

@@ -0,0 +1,356 @@
+var mountedPictures = [];
+on("resize")(window, function () {
+    mountedPictures.forEach(a => a.update());
+});
+var getstation = function (n, s) {
+    var scale = Math.pow(10, Math.round(Math.log(n) / Math.log(10)));
+    var step;
+    if (n / scale < 1) {
+        step = s ? .01 : .05;
+    } else {
+        step = s ? .05 : .1;
+    }
+    step = step * scale;
+    n = Math.round(n / step) * step;
+    return n;
+};
+var trimCoord = move.trimCoord;
+var isequal = (a, b) => a === b || Math.abs((a - b) / (a + b)) < 1e-12;
+function picture_(image = document.createElement("div")) {
+    var image_width, image_height;
+    var scaled, x, y, min_scale, loaded_scale, locked_scale, click_scale, loaded_x, loaded_y;
+    var origin_width, origin_height;
+    var max_scale = 10 * devicePixelRatio;
+    var shape = function () {
+        image.shape(x, y, scaled / devicePixelRatio, origin_rotate);
+    };
+    image.reshape = shape;
+    var park = function () {
+        if (image.park) image.park(x, y, scaled / devicePixelRatio, origin_rotate);
+    };
+    var setInitParams = function () {
+        if (!image.width) return;
+        image_width = image.width / devicePixelRatio;
+        image_height = image.height / devicePixelRatio;
+        origin_width = image.clientWidth;
+        origin_height = image.clientHeight;
+        origin_rotate = 0;
+        locked_scale = loaded_scale = Math.min(image.clientHeight / image_height, image.clientWidth / image_width);
+        if (loaded_scale >= 0.9) {
+            if (loaded_scale < 1.2) {
+                click_scale = 1;
+                loaded_scale = .8;
+            } else if (loaded_scale < max_scale) {
+                click_scale = loaded_scale;
+                loaded_scale = 1;
+            } else {
+                click_scale = max_scale;
+                loaded_scale = 1;
+            }
+        } else {
+            click_scale = 1;
+        }
+        loaded_x = (image.clientWidth - image_width * loaded_scale) / 2;
+        loaded_y = (image.clientHeight - image_height * loaded_scale) / 2;
+        min_scale = loaded_scale * .75;
+        scaled = loaded_scale;
+        x = loaded_x;
+        y = loaded_y;
+        updatexy();
+        set_unlock();
+    };
+    var set_unlock = function () {
+        if (!loaded_scale) return;
+        fixpos();
+        shape();
+    };
+
+    on("append")(image, setInitParams);
+
+    on("append")(image, function () {
+        mountedPictures.push(image);
+    });
+    on("remove")(image, function () {
+        removeFromList(mountedPictures, image);
+    });
+    image.init = setInitParams;
+    image.locked = false;
+    var last_click_time = 0;
+
+    on("click")(image, function (event) {
+        var time = +new Date;
+        var delta_time = time - last_click_time;
+        last_click_time = time;
+        if (delta_time > 300) return;
+        var image = this;
+        var __scaled = scaled, _x = x, _y = y;
+        setInitParams();
+        image.locked = isequal(__scaled, loaded_scale) && isequal(loaded_x, x) && isequal(loaded_y, y);
+        var layerx = event.offsetX || 0;
+        var layery = event.offsetY || 0;
+        if (layerx)
+            if (image.locked) {
+                var width = image_width * loaded_scale, height = image_height * loaded_scale;
+                if (layerx > loaded_x + width || layerx < loaded_x || width < image.offsetWidth >> 2) {
+                    layerx = loaded_x + width / 2;
+                }
+                if (layery > loaded_y + height || layery < loaded_y || height < image.offsetHeight >> 2) {
+                    layery = loaded_y + height / 2;
+                }
+                scale(layerx, layery, click_scale / loaded_scale);
+            } else {
+                set_unlock();
+            }
+    });
+    image.getScale = function () {
+        if (!this.locked && !loaded_scale) {
+            setInitParams();
+        }
+        return +String(+scaled + 0.00005).slice(0, 6);
+    };
+    var fixpos = function () {
+        var width = image_width * scaled;
+        var height = image_height * scaled;
+        var r = image.rotate | 0;
+        var [, , w, h] = getrotatedltwh(r);
+        var x0 = x + (width - w) / 2;
+        var y0 = y + (height - h) / 2;
+        var [x1, y1] = trimCoord([image.clientWidth, image.clientHeight], [x0, y0, w, h], -1);
+        x += x1 - x0;
+        y += y1 - y0;
+    };
+    var scale = function (layerx, layery, ratio) {
+        if (!image.locked) return;
+        scaled *= ratio;
+        x = (x - layerx) * ratio + layerx;
+        y = (y - layery) * ratio + layery;
+        shape();
+    };
+    var touch = function ([x1, y1, x2, y2], [m1, n1, m2, n2]) {
+        var l1 = Math.sqrt(Math.pow(m1 - m2, 2) + Math.pow(n1 - n2, 2));
+        var l2 = Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
+        var scale = l1 / l2;
+        if (scaled >= max_scale * 1.1 && scale > 1) return;
+        if (scaled <= min_scale && scale < 1) return;
+        scaled *= scale;
+        var centerx = (x1 + x2) / 2;
+        var centery = (y1 + y2) / 2;
+        var centerm = (m1 + m2) / 2;
+        var centern = (n1 + n2) / 2;
+        x = (x - centerx) * scale + centerm;
+        y = (y - centery) * scale + centern;
+        shape();
+    };
+    var recover = function (change) {
+        var aimed_scale = getstation(scaled);
+        if (aimed_scale !== scaled) {
+            change = true;
+            x = (x - image.clientWidth / 2) / scaled * aimed_scale + image.clientWidth / 2;
+            y = (y - image.clientHeight / 2) / scaled * aimed_scale + image.clientHeight / 2;
+            scaled = aimed_scale;
+        }
+        if (scaled <= loaded_scale * 1.2) {
+            scaled = loaded_scale;
+            x = loaded_x;
+            y = loaded_y;
+            change = true;
+        }
+        if (scaled > max_scale) {
+            change = true;
+            x = (x - image.clientWidth / 2) * max_scale / scaled + image.clientWidth / 2;
+            y = (y - image.clientHeight / 2) * max_scale / scaled + image.clientHeight / 2;
+            scaled = max_scale;
+        }
+        var saved_x = x, saved_y = y;
+        fixpos();
+        if (change || saved_x !== x || saved_y !== y) {
+            park();
+        }
+    };
+    var move = inertia(function (deltax, deltay) {
+        var saved_x = x, saved_y = y;
+        x += deltax, y += deltay;
+        fixpos();
+        shape();
+        if (saved_x === x && saved_y === y) return false;
+    });
+    var saved_event, wheeltime;
+    onmousewheel(image, function (event) {
+        var { offsetX: layerX, offsetY: layerY, deltaY } = event;
+        if (this.locked) event.preventDefault();
+        if (!deltaY) return;
+        if (!this.locked) setInitParams();
+        this.locked = true;
+        var ratio = Math.pow(0.99, 20 * Math.atan(deltaY / 20));
+        var __scaled = scaled;
+        __scaled *= ratio;
+        if (__scaled > max_scale && ratio > 1) {
+            __scaled = max_scale;
+        }
+        if (__scaled < min_scale && ratio < 1) {
+            __scaled = min_scale;
+        }
+        ratio = __scaled / scaled;
+        scale(layerX, layerY, ratio);
+    });
+    moveupon(image, {
+        start(event) {
+            event.preventDefault();
+            saved_event = event;
+            event.moveLocked = scaled > locked_scale;
+            if (!this.locked) {
+                setInitParams();
+            }
+            move.reset();
+        },
+        move(event) {
+            if (event.moveLocked) return;
+            event.moveLocked = scaled > locked_scale;
+            event.preventDefault();
+            if (event.touches && saved_event.touches) {
+                if (event.touches.length !== saved_event.touches.length) {
+                    saved_event = event;
+                    return;
+                }
+
+                switch (event.touches.length) {
+                    case 1:
+                        if (!this.locked) return;
+                        break;
+                    case 2:
+                        this.locked = true;
+                        event.moveLocked = true;
+                        var [xy1, xy2] = saved_event.touches;
+                        var [mn1, mn2] = event.touches;
+                        var { left, top } = getScreenPosition(image);
+                        top += image.clientTop;
+                        left += image.clientLeft;
+                        touch(
+                            [xy1.clientX - left, xy1.clientY - top, xy2.clientX - left, xy2.clientY - top],
+                            [mn1.clientX - left, mn1.clientY - top, mn2.clientX - left, mn2.clientY - top]
+                        );
+                        saved_event = event;
+                        return;
+                }
+            }
+            if (event.which === 3) {
+                event.moveLocked = true;
+                rotatexy(saved_event.clientX, saved_event.clientY, event.clientX, event.clientY);
+            }
+            else {
+                if (!this.locked) return;
+                var deltax = event.clientX - saved_event.clientX,
+                    deltay = event.clientY - saved_event.clientY;
+                move(deltax, deltay);
+            }
+            saved_event = event;
+        },
+        end(event) {
+            if (saved_event) {
+                if (event.timeStamp - saved_event.timeStamp > 120) {
+                    move.reset();
+                }
+            }
+            saved_event = null;
+            event.moveLocked = scaled >= locked_scale;
+
+            if (this.locked && onclick.preventClick) move.smooth(recover);
+        }
+    });
+    var origin_rotate = 0;
+    var rotatexy = function (x1, y1, x2, y2) {
+        var centerx = image.clientWidth / 2, centery = image.clientHeight / 2;
+        var deltax = x2 - x1, deltay = y2 - y1;
+        var rx = x1 - centerx, ry = y1 - centery;
+        var sign = -ry * deltax + rx * deltay;
+        var delta = 90 * Math.sqrt(deltax * deltax + deltay * deltay) / Math.sqrt(rx * rx + ry * ry);
+        if (delta > 10) delta = 10;
+        if (sign) image.rotateBy(sign > 0 ? delta : -delta);
+    }
+    var updatexy = function () {
+        var deg = image.rotate - origin_rotate;
+        if (isFinite(deg)) {
+            origin_rotate = image.rotate;
+            [x, y] = getrotatedltwh(deg, scaled);
+        }
+    };
+    var getrotatedltwh = function (a, s = scaled) {
+        var w = image_width * s;
+        var h = image_height * s;
+        var c = [image.clientWidth / 2, image.clientHeight / 2];
+        var m = x + w / 2;
+        var n = y + h / 2;
+        var [c1, c2] = rotate([m, n], -a, c);
+        c1 -= w / 2;
+        c2 -= h / 2;
+        var a = origin_rotate;
+        var l = c[0] - w / 2;
+        var r = l + w;
+        var t = c[1] - h / 2;
+        var b = t + h;
+        var [x1, y1] = rotate([l, t], a, c);
+        var [x2, y2] = rotate([r, t], a, c);
+        var [x3, y3] = rotate([l, b], a, c);
+        var [x4, y4] = rotate([r, b], a, c);
+        var l = Math.min(x1, x2, x3, x4);
+        var t = Math.min(y1, y2, y3, y4);
+        var w = Math.max(x1, x2, x3, x4) - l;
+        var h = Math.max(y1, y2, y3, y4) - t;
+        return [c1, c2, w, h];
+    };
+    image.update = function (animate) {
+        if (image.locked) {
+            updatexy();
+            x += (image.clientWidth - origin_width) / 2;
+            y += (image.clientHeight - origin_height) / 2;
+            origin_height = image.clientHeight;
+            origin_width = image.clientWidth;
+            if (animate !== false) fixpos();
+            shape();
+            return;
+        }
+        setInitParams();
+        if (animate !== false) {
+            recover();
+        } else {
+            if (animate !== false) fixpos();
+            shape();
+        }
+
+    };
+    image.rotateTo = function (deg) {
+        this.rotate = deg;
+        this.update();
+    };
+    image.rotateBy = function (deg) {
+        var r = this.rotate | 0;
+        if (deg === 90 || deg === -90) {
+            r += deg;
+            if (deg > 0) {
+                // 九进八舍
+                var a = r / 90;
+                if (Math.ceil(a) - a < .01) {
+                    r = Math.ceil(a) * 90;
+                } else {
+                    r = Math.floor(a) * 90;
+                }
+            } else {
+                // 一进零舍
+                var a = r / 90;
+                if (Math.ceil(a) - a > .01) {
+                    r = Math.ceil(a) * 90;
+                } else {
+                    r = Math.floor(a) * 90;
+                }
+            }
+        } else {
+            r += deg;
+        }
+        this.rotate = r;
+        this.update(deg === 90 || deg === -90);
+    };
+    on("contextmenu")(image, function (e) {
+        if (onclick.preventClick) e.preventDefault();
+    });
+    return image;
+}

package/coms/zimoli/prompt.js

@@ -25,8 +25,10 @@ function prompt(msg = "请输入", check) {
         });
     })
     on("mousedown")(c, e => e.target !== ipt && e.preventDefault() | ipt.focus());
-    on("keydown.enter")(c, function () {
+    on("keydown.enter")(c, function (event) {
+        if (event.defaultPrevented) return;
         if (check && check(ipt.value) === false) return;
+        event.preventDefault();
         oked = true;
         remove(c);
         fire();

package/coms/zimoli/render.js

@@ -1,6 +1,15 @@
 var hasOwnProperty = {}.hasOwnProperty;
 var renderElements = Object.create(null);
 var presets = Object.create(null);
+presets.template = function (t) {
+    var node = document.createElement("div");
+    var comment = document.createComment('template');
+    node.innerHTML = t.innerHTML;
+    comment.with = [].slice.call(node.childNodes, 0);
+    renderElement(comment.with, t.$scope, t.$parentScopes);
+    remove(node.childNodes);
+    return comment;
+};
 window.renderElements = renderElements;
 var renderidOffset = 10;
 var renderidClosed = 0;
@@ -70,7 +79,6 @@ var initialComment = function (renders, type, expression) {
     onremove(comment, removeRenderElement);
     appendChild.after(this, comment);
     if (!/if/i.test(type)) remove(this);
-    this.with = comment;
     rebuild(comment);
     return comment;
 };
@@ -214,17 +222,12 @@ var createIf = function (search, id = 0) {
             var element = elements[cx];
             if (cx === shouldMount) {
                 appendChild.before(this, element);
-                element.with = this;
                 if (element.renderid < 0) {
                     element.renderid = id;
-                    var w = element.with;
-                    delete element.with;
-                    element = render(element);
-                    element.with = w;
+                    elements[cx] = render(element);
                 }
             }
             else {
-                delete element.with;
                 remove(element);
             }
         }
@@ -624,7 +627,7 @@ function renderElement(element, scope = element.$scope, parentScopes = element.$
             if (parentNode.renderid > 1 || parentNode.isMounted) element.renderid = 2;
         }
         element.renders = element.renders ? [].concat(element.renders) : [];
-        var { ons, copys, attrs, props, binds, context: withContext } = element.$struct;
+        var { ons, copys, attrs, props, binds, context: withContext, ids } = element.$struct;
         delete element.$struct;
         if (binds.src) {
             element.$src = parseRepeat(binds.src);
@@ -672,7 +675,7 @@ function renderElement(element, scope = element.$scope, parentScopes = element.$
             }
         }
     }
-    if (element.children.length) renderElement(element.children, scope, parentScopes);
+    if (element.children && element.children.length) renderElement(element.children, scope, parentScopes);
     if (!isFirstRender) return element;
     for (var k in binds) {
         if (directives.hasOwnProperty(k)) {
@@ -698,6 +701,9 @@ function renderElement(element, scope = element.$scope, parentScopes = element.$
         if (element.isMounted || element.renderid > 1) addRenderElement.call(element);
     }
     if (elementid) scope[elementid] = element;
+    for (var id of ids) {
+        scope[id] = element;
+    }
     return element;
 }
 function renderStructure(element, scope, parentScopes = []) {
@@ -721,8 +727,14 @@ function renderStructure(element, scope, parentScopes = []) {
     var binds = {};
     var attr1 = {};
     var props = {};
+    var ids = [];
     for (var attr of attrs) {
         var { name, value } = attr;
+        if (/^#/.test(name)) {
+            ids.push(name.slice(1));
+            element.removeAttribute(name);
+            continue;
+        };
         if (/^(?:class|style|src|\:|placeholder)$/i.test(name)) {
             copys.push(attr);
             continue;
@@ -771,7 +783,7 @@ function renderStructure(element, scope, parentScopes = []) {
             props[name.replace(/\-(\w)/g, (_, w) => w.toUpperCase())] = value === "" ? true : value;
         }
     }
-    if (!element.$struct) element.$struct = { ons, copys, binds, attrs: attr1, props, context: withContext };
+    if (!element.$struct) element.$struct = { ons, copys, binds, attrs: attr1, props, context: withContext, ids };
     if (element.renderid <= -1) createStructure.call(element, types.if, types.repeat, withContext);
 }
 function render(element, scope, parentScopes) {

package/coms/zimoli/renderDefaults.js

@@ -34,6 +34,7 @@ extend(renderDefaults, {
     pic: img,
     image,
     back,
+    success,
     switch: swap,
     swap,
     password,

package/coms/zimoli/search.js

@@ -1,10 +1,11 @@
-function search(seartext, options) {
+function search(seartext, options, path = "name") {
     if (options instanceof Array) {
         var hasFullmatch = false;
         var a = options.map(o => {
-            if (o.name === seartext) hasFullmatch = true;
-            var [power, m] = mark.power(o.name, seartext);
-            return { power, name: m, value: o.value };
+            var name = seek(o, path);
+            if (name === seartext) hasFullmatch = true;
+            var [power, m] = mark.power(name, seartext);
+            return { power, [path]: m, value: o.value, item: o };
         }).filter(a => a.power > 0);
         a.sort(function (a, b) {
             return b.power - a.power;

package/coms/zimoli/select.js

@@ -24,6 +24,10 @@ var _remove = function () {
 var preventDefault = function (event) {
     event.preventDefault();
 };
+var preventDefault1 = function (event) {
+    if (saved_list) return;
+    event.preventDefault();
+}
 var lastTimeClick = 0;
 var removeByBlur = function () {
     if (!getTargetIn(this, document.activeElement)) _remove();
@@ -71,8 +75,8 @@ function select(target, list, removeOnSelect, direction) {
                     target.innerHTML = `<option selected value="${this.value}">${this.name || this.value}</option>`
                 }
                 target.value = this.value;
-                dispatch(target, "change");
             }
+            dispatch(target, "change");
         }
     };
     var onlistclick = function (event) {
@@ -96,8 +100,8 @@ function select(target, list, removeOnSelect, direction) {
         }
         on("keydown.up")(target, preventDefault);
         on("keydown.down")(target, preventDefault);
-        on("keydown.enter")(target, preventDefault);
-        on("keydown.space")(target, preventDefault);
+        on("keydown.enter")(target, preventDefault1);
+        on("keydown.space")(target, preventDefault1);
         var pop = function () {
             if (saved_list !== list) mousedown.call(this);
         };
@@ -116,7 +120,7 @@ function select(target, list, removeOnSelect, direction) {
     else if (target.$src) {
         var generator = getGenerator(target);
         var initList2 = function (src) {
-            list = selectList(generator, src, target.multiple, target.editable);
+            list = selectList(generator, src, !!target.multiple, !!target.editable);
             if (!target.multiple) {
                 onclick(list, onlistclick);
             }
@@ -158,7 +162,7 @@ function select(target, list, removeOnSelect, direction) {
             var allOptions = [].concat.apply([], target.querySelectorAll("option"));
             if (deepEqual.shallow(allOptions, savedOptions)) return;
             savedOptions = allOptions;
-            list = selectList(allOptions, target.multiple, target.editable);
+            list = selectList(allOptions, !!target.multiple, !!target.editable);
             if (!target.multiple) {
                 onclick(list, onlistclick);
             }

package/coms/zimoli/selectList.js

@@ -39,14 +39,17 @@ function main() {
                 generator = a;
                 break;
             case "boolean":
-                if (multiple === void 0) multiple = a;
-                else addable = a;
+            case "undefined":
+                if (multiple === void 0) multiple = !!a;
+                else addable = !!a;
+                break;
             case "object":
                 if (isNode(a)) {
                     page = a;
                     if (!generator) generator = getGenerator(page);
                 }
                 else if (a.length) children = a;
+                break;
 
         }
     }
@@ -57,7 +60,7 @@ function main() {
     function createItem(option) {
         var key = option.key || option.value;
         if (key in itemMap) return itemMap[key];
-        var item = itemMap[option.value] = document.createElement('div');
+        var item = itemMap[key] = document.createElement('div');
         item.setAttribute("item", '');
         item.innerHTML = option.innerHTML || option.name;
         item.name = option.name || option.innerHTML;
@@ -75,12 +78,12 @@ function main() {
             iconed = icon;
             if (multiple) {
                 item.setAttribute("selected", "");
-                page.value.push(option.value);
+                page.value.push(key);
             }
             else {
                 item.setAttribute("selected", "");
                 page.activeNode = item;
-                page.value = option.value
+                page.value = key
             }
         }
         if (option.disabled) {
@@ -139,10 +142,9 @@ function main() {
                     if (a in itemMap) return false;
                     cast(page.target, "add-option", a);
                     children.push({ name: a, key: a });
-                    page.insertBefore(createItem({
-                        name: a,
-                        value: a,
-                    }), adder);
+                    remove(page.children);
+                    page.go(children.length - 1);
+                    appendChild(page, adder);
                     break;
                 case this.children[1]:
                     var options = [].slice.call(children, 0, children.length);
@@ -213,6 +215,7 @@ function main() {
         moveFocus(0);
     })
     var enter = function (e) {
+        if (e.defaultPrevented) return;
         e.preventDefault();
         var e = page.getIndexedElement(focus);
         if (e) e.click();

package/coms/zimoli/selectListEdit.js

@@ -14,7 +14,7 @@ function main(options) {
         },
         del(o) {
             for (var cx = 0, dx = options.length; cx < dx; cx++) {
-                if (options[cx].value === o.value) {
+                if (options[cx] === o || options[cx] === o.item) {
                     var i = cx;
                     break;
                 }

package/coms/zimoli/success.js

@@ -0,0 +1,4 @@
+function success(e) {
+    if (!e) e = document.createElement('success');
+    return e;
+}

package/coms/zimoli/success.less

@@ -0,0 +1,13 @@
+& {
+    background: #2942;
+    color: #294;
+    font-size: 24px;
+    line-height: 2;
+    text-align: center;
+    display: block;
+    font-family: "仿宋", sans-serif;
+
+    &:before {
+        content: " ✓ ";
+    }
+}

package/coms/zimoli/table.html

@@ -1,16 +1,14 @@
-<thead>
-    <tr>
-        <td -repeat="f in fields track by f.id" :style="{width:f.width}"><i -if="f.icon"
+<tbody -src="d in data" :style="{'max-height':((innerHeight-46)/32|0)*32+36}">
+    <tr thead #adapter insert>
+        <td -repeat="f in fields track by f.id" :style="{width:f.width}" @dblclick="sort(f)"><i -if="f.icon"
                 -class="f.icon"></i></span><span -if="f.name" -html="f.name"></span>
         </td>
     </tr>
-</thead>
-<tbody -src="d in data">
     <tr>
         <td -repeat="f in fields">
-            <model -if="f.key" :field=f :data=d readonly ></model>
-            <a on-click="o.do(d)" -if="!f.key&&f.options&&(!o.when||o.when(d))" _type="o.type instanceof Function?o.type(d):o.type"
-                -repeat="o in f.options">
+            <model -if="f.key" :field=f :data=d readonly></model>
+            <a on-click="o.do(d)" -if="!f.key&&f.options&&(!o.when||o.when(d))"
+                _type="o.type instanceof Function?o.type(d):o.type" -repeat="o in f.options">
                 <span -text="o.name instanceof Function?o.name(d):o.name"></span>
             </a>
         </td>