efront 3.10.5 → 3.11.2

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/frame/route.js

@@ -33,7 +33,6 @@
     };
     var parseMenuList = function (items) {
         if (items instanceof Array) {
-            console.log(items)
             return items;
         }
         if (items instanceof Object) {

package/coms/zimoli/active.js

@@ -1,8 +1,12 @@
 // 激活 自定义的 active 事件
-function active(target, value, item) {
+function active(target, value, item, targetElement) {
     var activeEvent = createEvent("active");
     activeEvent.item = item;
     activeEvent.value = value;
+    if (targetElement) {
+        if (Object.defineProperty) Object.defineProperty(activeEvent, 'currentTarget', { value: targetElement });
+        else activeEvent.currentTarget = targetElement;
+    }
     activeEvent = dispatch(target, activeEvent);
     return activeEvent && !activeEvent.defaultPrevented;
 }

package/coms/zimoli/bindAccesskey.js

@@ -0,0 +1,47 @@
+var keyMap = {};
+on("keydown")(window, function (event) {
+    var { which } = event;
+    switch (event.which) {
+        case 18:
+            event.preventDefault();
+            break;
+        default:
+            var key = String.fromCharCode(which);
+            var elems = keyMap[key];
+            if (elems) while (elems.length) {
+                var elem = elems[elems.length - 1];
+                if (isMounted(elem)) break;
+                else elems.pop();
+            }
+            if (elem) {
+                var parent = elem.parentNode;
+                if (event.altKey || parent === document.activeElement || parent.ispop) {
+                    event.preventDefault();
+                    elem.click();
+                }
+            }
+    }
+});
+var bindAccesskey = function (btn, k) {
+    if (!keyMap[k]) keyMap[k] = [];
+    removeFromList(keyMap[k], btn);
+    keyMap[k].push(btn);
+    once("remove")(btn, function () {
+        removeFromList(keyMap[k], btn);
+    });
+};
+var getKeyFromText = function (btn) {
+    var { innerText } = btn;
+    var match = /\(\s*\_?\w\s*\)|\[\s*\_?\w\s*\]|\{\s*\_?\w\s*\}/.exec(innerText);
+    if (match) {
+        var accesskey = match[0].replace(/^\W*(\w)\W*$/g, '$1');
+    } else {
+        var accesskey = btn.getAttribute("accesskey");
+    }
+    if (!accesskey) return;
+    return accesskey.toUpperCase();
+}
+function main(elem, key = getKeyFromText(elem)) {
+    bindAccesskey(elem, key);
+    return elem;
+}

package/coms/zimoli/button.js

@@ -2,29 +2,6 @@ var _label = createElement("span");
 var track = createElement(div);
 track.className = "track";
 _label.className = "label";
-var keyMap = {};
-on("keydown")(window, function (event) {
-    var { which } = event;
-    switch (event.which) {
-        case 18:
-            event.preventDefault();
-            break;
-        default:
-            if (event.altKey) {
-                var key = String.fromCharCode(which);
-                var element = keyMap[key];
-
-                if (element) {
-                    if (isMounted(element)) {
-                        dispatch(window, 'mousedown');
-                        element.click();
-                    } else {
-                        delete keyMap[key];
-                    }
-                }
-            }
-    }
-});
 
 var btn = document.createElement("button");
 btn.tabIndex = 0;
@@ -76,17 +53,6 @@ var touchstart = function () {
     var canceltouchend = ontouchend(this, cancel);
     active.call(this);
 };
-var bindAccesskey = function (btn) {
-    var { innerText } = btn;
-    var match = /\(\s*\_?\w\s*\)|\[\s*\_?\w\s*\]|\{\s*\_?\w\s*\}/.exec(innerText);
-    if (match) {
-        var accesskey = match[0].replace(/^\W*(\w)\W*$/g, '$1');
-    } else {
-        var accesskey = btn.getAttribute("accesskey");
-    }
-    if (!accesskey) return;
-    keyMap[accesskey.toUpperCase()] = btn;
-};
 function button(texter, type) {
     var tracker = createElement(track);
     var _texter;

package/coms/zimoli/data.js

@@ -1048,7 +1048,8 @@ function getItem(instanceId, onlyFromLocalStorage = false) {
     return data;
 }
 function hasItem(instanceId) {
-    return sessionStorage.getItem(instanceId) || localStorage.getItem(instanceId);
+    const storageId = userPrefix + instanceId + pagePathName;
+    return sessionStorage.getItem(storageId) || localStorage.getItem(storageId);
 }
 var instanceListenerMap = {};
 var fireListener = function (instanceId, data) {

package/coms/zimoli/menu.js

@@ -148,20 +148,24 @@ function main(elem, mode) {
             case "x":
             case "horizonal":
                 var direction = 'x';
+                mode = "horizonal";
             case "v":
             case "y":
             case "vertical":
-                var emit = function (item) {
-                    active(elem, item, item.value);
+                var emit = function (item, target) {
+                    active(elem, item, item.value, target);
                 };
                 if ("$src" in elem) {
                     getGenerator(elem);
                     care(elem, function (src) {
                         menuList(elem, getTreeFromData(src), emit, direction);
+                        elem.registerAsRoot();
                     });
-                } else {
+                }
+                else {
                     var nodes = getArrayNodes(elem);
-                    elem = menuList(elem, nodes, emit);
+                    elem = menuList(elem, nodes, emit, direction);
+                    elem.registerAsRoot();
                 }
                 break;
             default:

package/coms/zimoli/menu.less

@@ -92,12 +92,19 @@ body:active & {
     display: block;
     overflow: hidden;
     text-overflow: hidden;
-    height: 40px;
+    line-height: 40px;
     position: relative;
-    border: 1px solid #18333c;
-    background-color: #18333c;
-    box-shadow: inset 0 0 12px #51ddf6, inset 0px -120px 120px -120px #51ddf6;
-    border-right: none;
+    border-bottom: 1px solid #18333c;
+    padding: 0;
+
+    menu-item {
+        display: inline-block;
+
+        &.has-children:after {
+            padding-top: 3px;
+            content: "﹀";
+        }
+    }
 
     >div {
         vertical-align: top;

package/coms/zimoli/menuItem.html

@@ -1,3 +1,3 @@
-<i ng-class="menu.icon" ng-if='useIcon||hasIcon||menu.icon'></i>
-<span ng-model="menu.name"></span>
+<i ng-class="icon" ng-if='useIcon||hasIcon'></i>
+<span ng-html="name"></span>
 <s></s>

package/coms/zimoli/menuItem.js

@@ -1,11 +1,15 @@
 function main(elem, scope, hasIcon) {
     var item = elem || document.createElement('menu-item');
     item.innerHTML = menuItem;
-    if (isObject(scope) && scope !== elem.$scope) {
-        render(item, { menu: scope, useIcon: hasIcon, hasIcon })
+    if (isObject(scope) && scope !== item.$scope) {
     }
     else {
-        extendIfNeeded(elem.$scope, { useIcon: false, hasIcon: false })
+        var scope = item.$scope;
     }
+    if (scope.menu) scope = scope.menu;
+    var name = scope.name;
+    var icon = scope.icon;
+    if (hasIcon === undefined) hasIcon = !!icon;
+    render(item.children, { useIcon: hasIcon, hasIcon, name, icon });
     return item;
 }

package/coms/zimoli/menuList.html

@@ -1,4 +1,4 @@
-<menu-item ng-repeat="menu in menus" ng-if="!menu.hidden" ng-click="open(menu,event)"
-    ng-mouseleave="clearTimeout(popTimer)" ng-mouseenter="popTimer=popMenu(menu,event)"
+<menu-item ng-repeat="menu in menus" ng-if="!menu.hidden" ng-click="open.call(this)"
+    ng-mouseleave="cancel()" ng-mouseenter="popMenu.call(this)"
     ng-class="{'has-children':menu.children&&menu.children.length,'warn':menu.type==='danger'||menu.type==='warn'||menu.type==='red'}">
 </menu-item>

package/coms/zimoli/menuList.js

@@ -1,4 +1,4 @@
-var mounted_menus = [], releaseTimer = 0;
+var mounted_menus = [], releaseTimer = 0, root_menu;
 var release = function () {
     clear();
     releaseTimer = setTimeout(function () {
@@ -8,46 +8,231 @@ var release = function () {
 var clear = function () {
     clearTimeout(releaseTimer);
 };
+var unfocus = function () {
+    remove(mounted_menus);
+    this.ispop = false;
+    this.setFocus();
+};
+var setFocus = function (focused = this.firstMenu) {
+    var page = this;
+    if (page.ispop || page === document.activeElement) {
+        if (page.focused !== focused) {
+            if (page.focused) removeClass(page.focused, 'focus');
+            if (focused) addClass(focused, "focus");
+            page.focused = focused;
+        }
+    }
+    else {
+        if (page.focused) {
+            removeClass(page.focused, 'focus');
+            page.focused = null;
+        }
+    }
+};
+var moveFocus = function (delta) {
+    var page = this;
+    var focused = page.focused;
+    var newIndex = 0;
+    if (!focused) {
+        if (delta > 0) newIndex = 0;
+        else newIndex = page.total - 1;
+    }
+    else {
+        var newIndex = focused.index + delta;
+        var total = page.total;
+        if (page !== root_menu) {
+            total++;
+        }
+        if (newIndex < 0) newIndex = total + newIndex;
+        if (newIndex > total - 1) newIndex = newIndex - total;
+    }
+
+    var e = page.getIndexedElement(newIndex);
+    if (!e) page.setFocus(null);
+    else page.open(e);
+};
+var openFocus = function () {
+    var menu = mounted_menus[mounted_menus.length - 1] || root_menu;
+    if (!menu.ispop) menu.ispop = 1;
+    menu.open(menu.focused);
+};
+var closeFocus = function () {
+    var menu = mounted_menus[mounted_menus.length - 1];
+    remove(menu);
+};
+var keyAction = function (deltax, deltay) {
+    if (root_menu !== document.activeElement) return;
+    var menu = mounted_menus[mounted_menus.length - 1];
+    if (menu) var parent = mounted_menus[mounted_menus.length - 2] || root_menu;
+    else menu = root_menu;
+
+    if (menu.direction === 'y') {
+        if (deltax === 1) {
+            if (menu.focused) openFocus();
+            else if (parent && parent.direction !== 'y') {
+                parent.moveFocus(deltax);
+            }
+        }
+        else if (deltax === -1) {
+            if (parent) {
+                if (parent.direction === 'y') remove(mounted_menus.pop());
+                else if (!menu.focused) parent.moveFocus(deltax);
+            }
+        }
+        else {
+            menu.moveFocus(deltay);
+        }
+    }
+    else {
+        if (deltay === 1) {
+            if (menu.focused) openFocus();
+            else if (parent && parent.direction === 'y') {
+                parent.moveFocus(deltay);
+            }
+        }
+        else if (deltay === -1) {
+            if (parent) {
+                if (parent.direction !== 'y') remove(mounted_menus.pop());
+                else if (!menu.focused) parent.moveFocus(deltay);
+            }
+        }
+        else {
+            menu.moveFocus(deltax);
+        }
+    }
+};
+function keyalt() {
+    if (root_menu === document.activeElement) root_menu.blur();
+    else {
+        root_menu.tabIndex = 0;
+        root_menu.focus();
+    }
+    root_menu.setFocus();
+}
+function keyesc() {
+    if (root_menu === document.activeElement && !mounted_menus.length) {
+        if (!root_menu.ispop) root_menu.blur(), root_menu.setFocus();
+        else root_menu.ispop = false;
+    }
+}
+function keyup() {
+    keyAction(0, -1);
+}
+function keydown() {
+    keyAction(0, 1);
+}
+function keyleft() {
+    keyAction(-1, 0)
+}
+function keyright() {
+    keyAction(1, 0);
+}
+function keyspace() {
+    if (root_menu !== document.activeElement) return;
+    var menu = mounted_menus[mounted_menus.length - 1];
+    if (!menu || !menu.focused) menu = mounted_menus[mounted_menus.length - 2] || root_menu;
+    if (menu.focused) {
+        menu.focused.click();
+    }
+}
+function register() {
+    // on('keydown.alt')(window, e => e.preventDefault());
+    on('keydown.alt.')(window, keyalt);
+    on('keydown.esc')(window, keyesc);
+    on('keydown.left')(window, keyleft);
+    on('keydown.right')(window, keyright);
+    on('keydown.up')(window, keyup);
+    on('keydown.down')(window, keydown);
+    on('keydown.enter')(window, keyspace);
+    on('keydown.space')(window, keyspace);
+    root_menu = this;
+}
 function main(page, items, active, direction = 'y') {
     if (!isNode(page)) {
         var page = div();
     }
     var main = this;
-    function popMenu(item, event) {
-        if (page.active) {
+    if (direction !== 'x') page.ispop = true;
+    function popMenu(item, target) {
+        if (page.actived) {
             clear();
-            remove(page.active);
+            remove(page.actived);
         }
+        page.setFocus(target);
         if (!item.children || !item.children.length) return;
         var clone = template.cloneNode();
+        clone.$parentScopes = page.$parentScopes;
+        clone.$src = src;
         clone.innerHTML = template.innerHTML;
         var menu = main(clone, item.children, active);
         mounted_menus.push(menu);
-
-        page.active = menu;
-        popup(menu, event.target);
-        var offleave0 = on("mouseleave")(event.target, release);
-        var offenter0 = on("mouseenter")(event.target, clear);
-        var offleave1 = on("mouseleave")(menu, release);
-        var offenter1 = on("mouseenter")(menu, clear);
+        page.actived = menu;
+        menu.root = page.root || page;
+        popup(menu, target);
+        if (page.ispop === true) {
+            var offleave0 = on("mouseleave")(target, release);
+            var offleave1 = on("mouseleave")(menu, release);
+            var offenter0 = on("mouseenter")(target, clear);
+            var offenter1 = on("mouseenter")(menu, clear);
+        } else {
+            page.ispop = 1;
+            page.tabIndex = 0;
+            page.focus();
+        }
+        on("mousedown")(menu, e => e.preventDefault());
         once("remove")(menu, function () {
-            removeFromList(mounted_menus, page.active);
-            offleave0();
-            offenter0();
-            offleave1();
-            offenter1();
+            removeFromList(mounted_menus, this);
+            if (offleave0) offleave0();
+            if (offleave1) offleave1();
+            if (offenter0) offenter0();
+            if (offenter1) offenter1();
         });
     }
-
-    var template = page.tempalte || page.cloneNode();
+    if (!page.ispop) on("blur")(page, unfocus);
+    var template = page.tempalte || document.createElement("ylist");
     if (!page.tempalte) {
         template.className = '';
         template.removeAttribute('mode');
         template.innerHTML = page.innerHTML;
         page.tempalte = template;
     }
+    var popTimer = 0;
+    var open = function () {
+        cancel();
+        var elem = this;
+        page.setFocus(elem);
+        if (page.ispop) popTimer = setTimeout(function () {
+            popMenu(elem.menu, elem);
+        }, 60);
+    };
+    var cancel = function () {
+        clearTimeout(popTimer);
+    }
+    var fire = function () {
+        cancel();
+        var pop = active(this.menu, this);
+        if (pop === false) return;
+        var root = page.root || page;
+        if (root.ispop === 1) root.ispop = false;
+        if (page.actived && page.actived.target === this) {
+            if (!mounted_menus.length) {
+                popMenu(this.menu, this);
+            }
+            else {
+                unfocus.call(page);
+            }
+        }
+        else {
+            while (mounted_menus.length && mounted_menus[mounted_menus.length - 1] !== page) remove(mounted_menus.pop());
+            popMenu(this.menu, this);
+            if (!page.actived) {
+                (page.root || page).blur();
+            }
+        }
+    };
+
+
     if (!page.children.length || page.menutype === 1) {
-        page.innerHTML = menuList;
         page.menutype = 1;
         var hasIcon = function () {
             var menus = items;
@@ -58,42 +243,93 @@ function main(page, items, active, direction = 'y') {
             }
             return false;
         };
-        render(page, {
-            "menu-item": function () {
-                return button(
-                    menuItem.apply(null, arguments)
+        var $scope = {
+            "menu-item": function (e, s) {
+                var a = bindAccesskey(
+                    menuItem(e, s, this.hasIcon)
                 );
+                if (!page.firstMenu) {
+                    page.firstMenu = a;
+                }
+                return a;
             },
             menus: items,
             hasIcon: hasIcon(),
-            open(menu, event) {
-                active(menu, event);
-            },
-            popTimer: 0,
-            popMenu() {
-                var args = arguments;
-                return setTimeout(function () {
-                    popMenu.apply(null, args);
-                }, 60);
-            },
-        });
-        vbox(page);
+            open: fire,
+            cancel,
+            popMenu: open,
+        };
+        if (page.$src) {
+            var src = page.$src;
+            var parentScopes = page.$parentScopes;
+            var itemName = src.itemName;
+            var className = `{'has-children':${itemName}.children&&${itemName}.children.length,'warn':${itemName}.type==='danger'||${itemName}.type==='warn'||${itemName}.type==='red'}`;
+            var notHidden = `!${itemName}.hidden`;
+
+            list(page, function (index) {
+                var item = items[index];
+                if (!item) return;
+                var a = $scope["menu-item"](null, item);
+                var scope = {};
+                if (item instanceof Item) item = item.value;
+                if (src.itemName) scope[src.itemName] = item;
+                else scope.$item = item;
+                if (src.keyName) scope[src.keyName] = index;
+                else scope.$key = index;
+                if (src.indexName) scope[src.indexName] = index;
+                else scope.$index = index;
+                if (src.srcName) scope[src.srcName] = items;
+                if (src.itemName) a.setAttribute("e-if", notHidden);
+                a.menu = item;
+                on("mouseleave")(a, cancel);
+                on("mouseenter")(a, open);
+                on("click")(a, fire);
+                a.setAttribute("e-class", className);
+                render(a, scope, parentScopes);
+                return a;
+            });
+            on("append")(page, function () {
+                this.go(0);
+            })
+        }
+        else {
+            page.innerHTML = menuList;
+            render(page, $scope);
+            vbox(page);
+        }
+        page.total = items.length;
         page.renders.unshift(function () {
             this.$scope.hasIcon = hasIcon();
         });
-    } else {
+    }
+    else {
         var generator = getGenerator(page);
+
         list(page, function (index) {
             var elem = generator(index);
             if (!elem) return;
-            on("mouseenter")(elem, function (event) {
-                popMenu(this.src[index], event);
-            });
-            on("click")(elem, function (event) {
-                active(this.src[index], event);
-            });
+            if (!page.firstMenu) {
+                page.firstMenu = elem;
+                page.total = this.src.length;
+            }
+            elem.menu = this.src[index];
+            on("mouseleave")(elem, cancel);
+            on("mouseenter")(elem, open);
+            on("click")(elem, fire);
             return elem;
         }, direction);
     }
+    page.open = function (a) {
+        open.call(a);
+    };
+    page.active = function (a) {
+        fire.call(a);
+    };
+    page.registerAsRoot = register;
+    page.setFocus = setFocus;
+    page.moveFocus = moveFocus;
+    page.openFocus = openFocus;
+    page.closeFocus = closeFocus;
+    page.direction = direction;
     return page;
 }

package/coms/zimoli/menuList.less

@@ -17,10 +17,15 @@
         color: inherit;
         box-shadow: none;
         text-align: inherit;
-        &.warn{
+
+        &.warn {
             color: #c28;
         }
 
+        &.focus {
+            color: #29c;
+        }
+
         &.has-children {
             padding: 0 24px 0 16px;
 

package/coms/zimoli/on.js

@@ -2,7 +2,7 @@
 var is_addEventListener_enabled = "addEventListener" in window;
 var handlersMap = {};
 var changes_key = 'changes';
-var eventtypereg = /(?:\.once|\.prevent|\.stop|\.capture|\.self|\.passive|\.[a-z0-9]+)+$/i;
+var eventtypereg = /(?:\.once|\.prevent|\.stop|\.capture|\.self|\.passive|\.[a-z0-9]+)+\.?$/i;
 var keyCodeMap = {
     backspace: 8,
     tab: 9,
@@ -118,6 +118,9 @@ var parseEventTypes = function (eventtypes) {
                 case "ctrl":
                     keyneed.push(t);
                     break;
+                case "":
+                    if (!types.keyCode) types.keyCode = true;
+                    break;
                 default:
                     if (isFinite(t)) {
                         types.keyCode = +t;
@@ -133,12 +136,20 @@ var parseEventTypes = function (eventtypes) {
     return types;
 }
 function checkKeyNeed(eventtypes, e) {
+    var keyneed = eventtypes.keyNeed;
     if (eventtypes.keyNeed) {
-        for (var cx = 0, dx = eventtypes.keyNeed.length; cx < dx; cx++) {
-            var key = eventtypes.keyNeed[cx];
+        for (var cx = 0, dx = keyneed.length; cx < dx; cx++) {
+            var key = keyneed[cx];
             if (!e[key + "Key"]) return false;
         }
     }
+    if (eventtypes.keyCode === true) {
+        for (var cx = 0, dx = keyneed.length; cx < dx; cx++) {
+            var key = keyneed[cx];
+            if (e.keyCode === keyCodeMap[key]) return true;
+        }
+        return false;
+    }
     if (eventtypes.keyCode) {
         return e.keyCode === eventtypes.keyCode;
     }