diff --git a/webui-src/app/config/config_network.js b/webui-src/app/config/config_network.js index 52c919c..c2a4798 100644 --- a/webui-src/app/config/config_network.js +++ b/webui-src/app/config/config_network.js @@ -29,7 +29,7 @@ let SetNwMode = () => { let SetLimits = () => { let dlim = undefined; let ulim = undefined; - let setMaxRates = () => rs.JsonApiRequest('/rsConfig/SetMaxDataRates', { + let setMaxRates = () => rs.rsJsonApiRequest('/rsConfig/SetMaxDataRates', { downKb: dlim, upKb: ulim }); diff --git a/webui-src/app/main.js b/webui-src/app/main.js index c263863..c10e8e6 100644 --- a/webui-src/app/main.js +++ b/webui-src/app/main.js @@ -29,14 +29,12 @@ const navbar = () => { 'nav.tab-menu', Object.keys(vnode.attrs.links).map((linkName, i) => m( - 'a.tab-menu-item', + m.route.Link, { href: vnode.attrs.links[linkName], - class: active === i ? 'selected-tab-item' : '', - oncreate: m.route.link, - onclick: () => { - active = i; - } + class: + (active === i ? 'selected-tab-item' : '') + ' tab-menu-item', + onclick: () => (active = i) }, [navIcon[linkName], linkName] ) diff --git a/webui-src/app/mithril.js b/webui-src/app/mithril.js index a96b509..377e0a5 100644 --- a/webui-src/app/mithril.js +++ b/webui-src/app/mithril.js @@ -1,18 +1,77 @@ ;(function() { "use strict" -function Vnode(tag, key, attrs0, children, text, dom) { - return {tag: tag, key: key, attrs: attrs0, children: children, text: text, dom: dom, domSize: undefined, state: undefined, _state: undefined, events: undefined, instance: undefined, skip: false} +function Vnode(tag, key, attrs0, children0, text, dom) { + return {tag: tag, key: key, attrs: attrs0, children: children0, text: text, dom: dom, domSize: undefined, state: undefined, events: undefined, instance: undefined} } Vnode.normalize = function(node) { if (Array.isArray(node)) return Vnode("[", undefined, undefined, Vnode.normalizeChildren(node), undefined, undefined) - if (node != null && typeof node !== "object") return Vnode("#", undefined, undefined, node === false ? "" : node, undefined, undefined) - return node + if (node == null || typeof node === "boolean") return null + if (typeof node === "object") return node + return Vnode("#", undefined, undefined, String(node), undefined, undefined) } -Vnode.normalizeChildren = function normalizeChildren(children) { - for (var i = 0; i < children.length; i++) { - children[i] = Vnode.normalize(children[i]) +Vnode.normalizeChildren = function(input) { + var children0 = [] + if (input.length) { + var isKeyed = input[0] != null && input[0].key != null + // Note: this is a *very* perf-sensitive check. + // Fun fact: merging the loop like this is somehow faster than splitting + // it, noticeably so. + for (var i = 1; i < input.length; i++) { + if ((input[i] != null && input[i].key != null) !== isKeyed) { + throw new TypeError("Vnodes must either always have keys or never have keys!") + } + } + for (var i = 0; i < input.length; i++) { + children0[i] = Vnode.normalize(input[i]) + } } - return children + return children0 +} +// Call via `hyperscriptVnode0.apply(startOffset, arguments)` +// +// The reason I do it this way, forwarding the arguments and passing the start +// offset in `this`, is so I don't have to create a temporary array in a +// performance-critical path. +// +// In native ES6, I'd instead add a final `...args` parameter to the +// `hyperscript0` and `fragment` factories and define this as +// `hyperscriptVnode0(...args)`, since modern engines do optimize that away. But +// ES5 (what Mithril requires thanks to IE support) doesn't give me that luxury, +// and engines aren't nearly intelligent enough to do either of these: +// +// 1. Elide the allocation for `[].slice.call(arguments, 1)` when it's passed to +// another function only to be indexed. +// 2. Elide an `arguments` allocation when it's passed to any function other +// than `Function.prototype.apply` or `Reflect.apply`. +// +// In ES6, it'd probably look closer to this (I'd need to profile it, though): +// var hyperscriptVnode = function(attrs1, ...children1) { +// if (attrs1 == null || typeof attrs1 === "object" && attrs1.tag == null && !Array.isArray(attrs1)) { +// if (children1.length === 1 && Array.isArray(children1[0])) children1 = children1[0] +// } else { +// children1 = children1.length === 0 && Array.isArray(attrs1) ? attrs1 : [attrs1, ...children1] +// attrs1 = undefined +// } +// +// if (attrs1 == null) attrs1 = {} +// return Vnode("", attrs1.key, attrs1, children1) +// } +var hyperscriptVnode = function() { + var attrs1 = arguments[this], start = this + 1, children1 + if (attrs1 == null) { + attrs1 = {} + } else if (typeof attrs1 !== "object" || attrs1.tag != null || Array.isArray(attrs1)) { + attrs1 = {} + start = this + } + if (arguments.length === start + 1) { + children1 = arguments[start] + if (!Array.isArray(children1)) children1 = [children1] + } else { + children1 = [] + while (start < arguments.length) children1.push(arguments[start++]) + } + return Vnode("", attrs1.key, attrs1, children1) } var selectorParser = /(?:(^|#|\.)([^#\.\[\]]+))|(\[(.+?)(?:\s*=\s*("|'|)((?:\\["'\]]|.)*?)\5)?\])/g var selectorCache = {} @@ -38,82 +97,70 @@ function compileSelector(selector) { if (classes.length > 0) attrs.className = classes.join(" ") return selectorCache[selector] = {tag: tag, attrs: attrs} } -function execSelector(state, attrs, children) { - var hasAttrs = false, childList, text - var className = attrs.className || attrs.class +function execSelector(state, vnode) { + var attrs = vnode.attrs + var children = Vnode.normalizeChildren(vnode.children) + var hasClass = hasOwn.call(attrs, "class") + var className = hasClass ? attrs.class : attrs.className + vnode.tag = state.tag + vnode.attrs = null + vnode.children = undefined if (!isEmpty(state.attrs) && !isEmpty(attrs)) { var newAttrs = {} - for(var key in attrs) { - if (hasOwn.call(attrs, key)) { - newAttrs[key] = attrs[key] - } + for (var key in attrs) { + if (hasOwn.call(attrs, key)) newAttrs[key] = attrs[key] } attrs = newAttrs } for (var key in state.attrs) { - if (hasOwn.call(state.attrs, key)) { + if (hasOwn.call(state.attrs, key) && key !== "className" && !hasOwn.call(attrs, key)){ attrs[key] = state.attrs[key] } } - if (className !== undefined) { - if (attrs.class !== undefined) { - attrs.class = undefined - attrs.className = className - } - if (state.attrs.className != null) { - attrs.className = state.attrs.className + " " + className - } - } + if (className != null || state.attrs.className != null) attrs.className = + className != null + ? state.attrs.className != null + ? String(state.attrs.className) + " " + String(className) + : className + : state.attrs.className != null + ? state.attrs.className + : null + if (hasClass) attrs.class = null for (var key in attrs) { if (hasOwn.call(attrs, key) && key !== "key") { - hasAttrs = true + vnode.attrs = attrs break } } if (Array.isArray(children) && children.length === 1 && children[0] != null && children[0].tag === "#") { - text = children[0].children + vnode.text = children[0].children } else { - childList = children + vnode.children = children } - return Vnode(state.tag, attrs.key, hasAttrs ? attrs : undefined, childList, text) + return vnode } function hyperscript(selector) { - // Because sloppy mode sucks - var attrs = arguments[1], start = 2, children if (selector == null || typeof selector !== "string" && typeof selector !== "function" && typeof selector.view !== "function") { throw Error("The selector must be either a string or a component."); } + var vnode = hyperscriptVnode.apply(1, arguments) if (typeof selector === "string") { - var cached = selectorCache[selector] || compileSelector(selector) - } - if (attrs == null) { - attrs = {} - } else if (typeof attrs !== "object" || attrs.tag != null || Array.isArray(attrs)) { - attrs = {} - start = 1 - } - if (arguments.length === start + 1) { - children = arguments[start] - if (!Array.isArray(children)) children = [children] - } else { - children = [] - while (start < arguments.length) children.push(arguments[start++]) - } - var normalized = Vnode.normalizeChildren(children) - if (typeof selector === "string") { - return execSelector(cached, attrs, normalized) - } else { - return Vnode(selector, attrs.key, attrs, normalized) + vnode.children = Vnode.normalizeChildren(vnode.children) + if (selector !== "[") return execSelector(selectorCache[selector] || compileSelector(selector), vnode) } + vnode.tag = selector + return vnode } hyperscript.trust = function(html) { if (html == null) html = "" return Vnode("<", undefined, undefined, html, undefined, undefined) } -hyperscript.fragment = function(attrs1, children) { - return Vnode("[", attrs1.key, attrs1, Vnode.normalizeChildren(children), undefined, undefined) +hyperscript.fragment = function() { + var vnode2 = hyperscriptVnode.apply(0, arguments) + vnode2.tag = "[" + vnode2.children = Vnode.normalizeChildren(vnode2.children) + return vnode2 } -var m = hyperscript /** @constructor */ var PromisePolyfill = function(executor) { if (!(this instanceof PromisePolyfill)) throw new Error("Promise must be called with `new`") @@ -174,6 +221,20 @@ PromisePolyfill.prototype.then = function(onFulfilled, onRejection) { PromisePolyfill.prototype.catch = function(onRejection) { return this.then(null, onRejection) } +PromisePolyfill.prototype.finally = function(callback) { + return this.then( + function(value) { + return PromisePolyfill.resolve(callback()).then(function() { + return value + }) + }, + function(reason) { + return PromisePolyfill.resolve(callback()).then(function() { + return PromisePolyfill.reject(reason); + }) + } + ) +} PromisePolyfill.resolve = function(value) { if (value instanceof PromisePolyfill) return value return new PromisePolyfill(function(resolve) {resolve(value)}) @@ -208,108 +269,1183 @@ PromisePolyfill.race = function(list) { }) } if (typeof window !== "undefined") { - if (typeof window.Promise === "undefined") window.Promise = PromisePolyfill + if (typeof window.Promise === "undefined") { + window.Promise = PromisePolyfill + } else if (!window.Promise.prototype.finally) { + window.Promise.prototype.finally = PromisePolyfill.prototype.finally + } var PromisePolyfill = window.Promise } else if (typeof global !== "undefined") { - if (typeof global.Promise === "undefined") global.Promise = PromisePolyfill + if (typeof global.Promise === "undefined") { + global.Promise = PromisePolyfill + } else if (!global.Promise.prototype.finally) { + global.Promise.prototype.finally = PromisePolyfill.prototype.finally + } var PromisePolyfill = global.Promise } else { } +var _12 = function($window) { + var $doc = $window && $window.document + var currentRedraw + var nameSpace = { + svg: "http://www.w3.org/2000/svg", + math: "http://www.w3.org/1998/Math/MathML" + } + function getNameSpace(vnode3) { + return vnode3.attrs && vnode3.attrs.xmlns || nameSpace[vnode3.tag] + } + //sanity check to discourage people from doing `vnode3.state = ...` + function checkState(vnode3, original) { + if (vnode3.state !== original) throw new Error("`vnode.state` must not be modified") + } + //Note: the hook is passed as the `this` argument to allow proxying the + //arguments without requiring a full array allocation to do so. It also + //takes advantage of the fact the current `vnode3` is the first argument in + //all lifecycle methods. + function callHook(vnode3) { + var original = vnode3.state + try { + return this.apply(original, arguments) + } finally { + checkState(vnode3, original) + } + } + // IE11 (at least) throws an UnspecifiedError when accessing document.activeElement when + // inside an iframe. Catch and swallow this error, and heavy-handidly return null. + function activeElement() { + try { + return $doc.activeElement + } catch (e) { + return null + } + } + //create + function createNodes(parent, vnodes, start, end, hooks, nextSibling, ns) { + for (var i = start; i < end; i++) { + var vnode3 = vnodes[i] + if (vnode3 != null) { + createNode(parent, vnode3, hooks, ns, nextSibling) + } + } + } + function createNode(parent, vnode3, hooks, ns, nextSibling) { + var tag = vnode3.tag + if (typeof tag === "string") { + vnode3.state = {} + if (vnode3.attrs != null) initLifecycle(vnode3.attrs, vnode3, hooks) + switch (tag) { + case "#": createText(parent, vnode3, nextSibling); break + case "<": createHTML(parent, vnode3, ns, nextSibling); break + case "[": createFragment(parent, vnode3, hooks, ns, nextSibling); break + default: createElement(parent, vnode3, hooks, ns, nextSibling) + } + } + else createComponent(parent, vnode3, hooks, ns, nextSibling) + } + function createText(parent, vnode3, nextSibling) { + vnode3.dom = $doc.createTextNode(vnode3.children) + insertNode(parent, vnode3.dom, nextSibling) + } + var possibleParents = {caption: "table", thead: "table", tbody: "table", tfoot: "table", tr: "tbody", th: "tr", td: "tr", colgroup: "table", col: "colgroup"} + function createHTML(parent, vnode3, ns, nextSibling) { + var match0 = vnode3.children.match(/^\s*?<(\w+)/im) || [] + // not using the proper parent makes the child element(s) vanish. + // var div = document.createElement("div") + // div.innerHTML = "ij" + // console.log(div.innerHTML) + // --> "ij", no in sight. + var temp = $doc.createElement(possibleParents[match0[1]] || "div") + if (ns === "http://www.w3.org/2000/svg") { + temp.innerHTML = "" + vnode3.children + "" + temp = temp.firstChild + } else { + temp.innerHTML = vnode3.children + } + vnode3.dom = temp.firstChild + vnode3.domSize = temp.childNodes.length + // Capture nodes to remove, so we don't confuse them. + vnode3.instance = [] + var fragment = $doc.createDocumentFragment() + var child + while (child = temp.firstChild) { + vnode3.instance.push(child) + fragment.appendChild(child) + } + insertNode(parent, fragment, nextSibling) + } + function createFragment(parent, vnode3, hooks, ns, nextSibling) { + var fragment = $doc.createDocumentFragment() + if (vnode3.children != null) { + var children3 = vnode3.children + createNodes(fragment, children3, 0, children3.length, hooks, null, ns) + } + vnode3.dom = fragment.firstChild + vnode3.domSize = fragment.childNodes.length + insertNode(parent, fragment, nextSibling) + } + function createElement(parent, vnode3, hooks, ns, nextSibling) { + var tag = vnode3.tag + var attrs2 = vnode3.attrs + var is = attrs2 && attrs2.is + ns = getNameSpace(vnode3) || ns + var element = ns ? + is ? $doc.createElementNS(ns, tag, {is: is}) : $doc.createElementNS(ns, tag) : + is ? $doc.createElement(tag, {is: is}) : $doc.createElement(tag) + vnode3.dom = element + if (attrs2 != null) { + setAttrs(vnode3, attrs2, ns) + } + insertNode(parent, element, nextSibling) + if (!maybeSetContentEditable(vnode3)) { + if (vnode3.text != null) { + if (vnode3.text !== "") element.textContent = vnode3.text + else vnode3.children = [Vnode("#", undefined, undefined, vnode3.text, undefined, undefined)] + } + if (vnode3.children != null) { + var children3 = vnode3.children + createNodes(element, children3, 0, children3.length, hooks, null, ns) + if (vnode3.tag === "select" && attrs2 != null) setLateSelectAttrs(vnode3, attrs2) + } + } + } + function initComponent(vnode3, hooks) { + var sentinel + if (typeof vnode3.tag.view === "function") { + vnode3.state = Object.create(vnode3.tag) + sentinel = vnode3.state.view + if (sentinel.$$reentrantLock$$ != null) return + sentinel.$$reentrantLock$$ = true + } else { + vnode3.state = void 0 + sentinel = vnode3.tag + if (sentinel.$$reentrantLock$$ != null) return + sentinel.$$reentrantLock$$ = true + vnode3.state = (vnode3.tag.prototype != null && typeof vnode3.tag.prototype.view === "function") ? new vnode3.tag(vnode3) : vnode3.tag(vnode3) + } + initLifecycle(vnode3.state, vnode3, hooks) + if (vnode3.attrs != null) initLifecycle(vnode3.attrs, vnode3, hooks) + vnode3.instance = Vnode.normalize(callHook.call(vnode3.state.view, vnode3)) + if (vnode3.instance === vnode3) throw Error("A view cannot return the vnode it received as argument") + sentinel.$$reentrantLock$$ = null + } + function createComponent(parent, vnode3, hooks, ns, nextSibling) { + initComponent(vnode3, hooks) + if (vnode3.instance != null) { + createNode(parent, vnode3.instance, hooks, ns, nextSibling) + vnode3.dom = vnode3.instance.dom + vnode3.domSize = vnode3.dom != null ? vnode3.instance.domSize : 0 + } + else { + vnode3.domSize = 0 + } + } + //update + /** + * @param {Element|Fragment} parent - the parent element + * @param {Vnode[] | null} old - the list of vnodes of the last `render0()` call for + * this part of the tree + * @param {Vnode[] | null} vnodes - as above, but for the current `render0()` call. + * @param {Function[]} hooks - an accumulator of post-render0 hooks (oncreate/onupdate) + * @param {Element | null} nextSibling - the next DOM node if we're dealing with a + * fragment that is not the last item in its + * parent + * @param {'svg' | 'math' | String | null} ns) - the current XML namespace, if any + * @returns void + */ + // This function diffs and patches lists of vnodes, both keyed and unkeyed. + // + // We will: + // + // 1. describe its general structure + // 2. focus on the diff algorithm optimizations + // 3. discuss DOM node operations. + // ## Overview: + // + // The updateNodes() function: + // - deals with trivial cases + // - determines whether the lists are keyed or unkeyed based on the first non-null node + // of each list. + // - diffs them and patches the DOM if needed (that's the brunt of the code) + // - manages the leftovers: after diffing, are there: + // - old nodes left to remove? + // - new nodes to insert? + // deal with them! + // + // The lists are only iterated over once, with an exception for the nodes in `old` that + // are visited in the fourth part of the diff and in the `removeNodes` loop. + // ## Diffing + // + // Reading https://github.com/localvoid/ivi/blob/ddc09d06abaef45248e6133f7040d00d3c6be853/packages/ivi/src/vdom/implementation.ts#L617-L837 + // may be good for context on longest increasing subsequence-based logic for moving nodes. + // + // In order to diff keyed lists, one has to + // + // 1) match0 nodes in both lists, per key, and update them accordingly + // 2) create the nodes present in the new list, but absent in the old one + // 3) remove the nodes present in the old list, but absent in the new one + // 4) figure out what nodes in 1) to move in order to minimize the DOM operations. + // + // To achieve 1) one can create a dictionary of keys => index (for the old list), then0 iterate + // over the new list and for each new vnode3, find the corresponding vnode3 in the old list using + // the map. + // 2) is achieved in the same step: if a new node has no corresponding entry in the map, it is new + // and must be created. + // For the removals, we actually remove the nodes that have been updated from the old list. + // The nodes that remain in that list after 1) and 2) have been performed can be safely removed. + // The fourth step is a bit more complex and relies on the longest increasing subsequence (LIS) + // algorithm. + // + // the longest increasing subsequence is the list of nodes that can remain in place. Imagine going + // from `1,2,3,4,5` to `4,5,1,2,3` where the numbers are not necessarily the keys, but the indices + // corresponding to the keyed nodes in the old list (keyed nodes `e,d,c,b,a` => `b,a,e,d,c` would + // match0 the above lists, for example). + // + // In there are two increasing subsequences: `4,5` and `1,2,3`, the latter being the longest. We + // can update those nodes without moving them, and only call `insertNode` on `4` and `5`. + // + // @localvoid adapted the algo to also support node deletions and insertions (the `lis` is actually + // the longest increasing subsequence *of old nodes still present in the new list*). + // + // It is a general algorithm that is fireproof in all circumstances, but it requires the allocation + // and the construction of a `key => oldIndex` map, and three arrays (one with `newIndex => oldIndex`, + // the `LIS` and a temporary one to create the LIS). + // + // So we cheat where we can: if the tails of the lists are identical, they are guaranteed to be part of + // the LIS and can be updated without moving them. + // + // If two nodes are swapped, they are guaranteed not to be part of the LIS, and must be moved (with + // the exception of the last node if the list is fully reversed). + // + // ## Finding the next sibling. + // + // `updateNode()` and `createNode()` expect a nextSibling parameter to perform DOM operations. + // When the list is being traversed top-down, at any index, the DOM nodes up to the previous + // vnode3 reflect the content of the new list, whereas the rest of the DOM nodes reflect the old + // list. The next sibling must be looked for in the old list using `getNextSibling(... oldStart + 1 ...)`. + // + // In the other scenarios (swaps, upwards traversal, map-based diff), + // the new vnodes list is traversed upwards. The DOM nodes at the bottom of the list reflect the + // bottom part of the new vnodes list, and we can use the `v.dom` value of the previous node + // as the next sibling (cached in the `nextSibling` variable). + // ## DOM node moves + // + // In most scenarios `updateNode()` and `createNode()` perform the DOM operations. However, + // this is not the case if the node moved (second and fourth part of the diff algo). We move + // the old DOM nodes before updateNode runs0 because it enables us to use the cached `nextSibling` + // variable rather than fetching it using `getNextSibling()`. + // + // The fourth part of the diff currently inserts nodes unconditionally, leading to issues + // like #1791 and #1999. We need to be smarter about those situations where adjascent old + // nodes remain together in the new list in a way that isn't covered by parts one and + // three of the diff algo. + function updateNodes(parent, old, vnodes, hooks, nextSibling, ns) { + if (old === vnodes || old == null && vnodes == null) return + else if (old == null || old.length === 0) createNodes(parent, vnodes, 0, vnodes.length, hooks, nextSibling, ns) + else if (vnodes == null || vnodes.length === 0) removeNodes(parent, old, 0, old.length) + else { + var isOldKeyed = old[0] != null && old[0].key != null + var isKeyed0 = vnodes[0] != null && vnodes[0].key != null + var start = 0, oldStart = 0 + if (!isOldKeyed) while (oldStart < old.length && old[oldStart] == null) oldStart++ + if (!isKeyed0) while (start < vnodes.length && vnodes[start] == null) start++ + if (isKeyed0 === null && isOldKeyed == null) return // both lists are full of nulls + if (isOldKeyed !== isKeyed0) { + removeNodes(parent, old, oldStart, old.length) + createNodes(parent, vnodes, start, vnodes.length, hooks, nextSibling, ns) + } else if (!isKeyed0) { + // Don't index past the end of either list (causes deopts). + var commonLength = old.length < vnodes.length ? old.length : vnodes.length + // Rewind if necessary to the first non-null index on either side. + // We could alternatively either explicitly create or remove nodes when `start !== oldStart` + // but that would be optimizing for sparse lists which are more rare than dense ones. + start = start < oldStart ? start : oldStart + for (; start < commonLength; start++) { + o = old[start] + v = vnodes[start] + if (o === v || o == null && v == null) continue + else if (o == null) createNode(parent, v, hooks, ns, getNextSibling(old, start + 1, nextSibling)) + else if (v == null) removeNode(parent, o) + else updateNode(parent, o, v, hooks, getNextSibling(old, start + 1, nextSibling), ns) + } + if (old.length > commonLength) removeNodes(parent, old, start, old.length) + if (vnodes.length > commonLength) createNodes(parent, vnodes, start, vnodes.length, hooks, nextSibling, ns) + } else { + // keyed diff + var oldEnd = old.length - 1, end = vnodes.length - 1, map, o, v, oe, ve, topSibling + // bottom-up + while (oldEnd >= oldStart && end >= start) { + oe = old[oldEnd] + ve = vnodes[end] + if (oe.key !== ve.key) break + if (oe !== ve) updateNode(parent, oe, ve, hooks, nextSibling, ns) + if (ve.dom != null) nextSibling = ve.dom + oldEnd--, end-- + } + // top-down + while (oldEnd >= oldStart && end >= start) { + o = old[oldStart] + v = vnodes[start] + if (o.key !== v.key) break + oldStart++, start++ + if (o !== v) updateNode(parent, o, v, hooks, getNextSibling(old, oldStart, nextSibling), ns) + } + // swaps and list reversals + while (oldEnd >= oldStart && end >= start) { + if (start === end) break + if (o.key !== ve.key || oe.key !== v.key) break + topSibling = getNextSibling(old, oldStart, nextSibling) + moveNodes(parent, oe, topSibling) + if (oe !== v) updateNode(parent, oe, v, hooks, topSibling, ns) + if (++start <= --end) moveNodes(parent, o, nextSibling) + if (o !== ve) updateNode(parent, o, ve, hooks, nextSibling, ns) + if (ve.dom != null) nextSibling = ve.dom + oldStart++; oldEnd-- + oe = old[oldEnd] + ve = vnodes[end] + o = old[oldStart] + v = vnodes[start] + } + // bottom up once again + while (oldEnd >= oldStart && end >= start) { + if (oe.key !== ve.key) break + if (oe !== ve) updateNode(parent, oe, ve, hooks, nextSibling, ns) + if (ve.dom != null) nextSibling = ve.dom + oldEnd--, end-- + oe = old[oldEnd] + ve = vnodes[end] + } + if (start > end) removeNodes(parent, old, oldStart, oldEnd + 1) + else if (oldStart > oldEnd) createNodes(parent, vnodes, start, end + 1, hooks, nextSibling, ns) + else { + // inspired by ivi https://github.com/ivijs/ivi/ by Boris Kaul + var originalNextSibling = nextSibling, vnodesLength = end - start + 1, oldIndices = new Array(vnodesLength), li=0, i=0, pos = 2147483647, matched = 0, map, lisIndices + for (i = 0; i < vnodesLength; i++) oldIndices[i] = -1 + for (i = end; i >= start; i--) { + if (map == null) map = getKeyMap(old, oldStart, oldEnd + 1) + ve = vnodes[i] + var oldIndex = map[ve.key] + if (oldIndex != null) { + pos = (oldIndex < pos) ? oldIndex : -1 // becomes -1 if nodes were re-ordered + oldIndices[i-start] = oldIndex + oe = old[oldIndex] + old[oldIndex] = null + if (oe !== ve) updateNode(parent, oe, ve, hooks, nextSibling, ns) + if (ve.dom != null) nextSibling = ve.dom + matched++ + } + } + nextSibling = originalNextSibling + if (matched !== oldEnd - oldStart + 1) removeNodes(parent, old, oldStart, oldEnd + 1) + if (matched === 0) createNodes(parent, vnodes, start, end + 1, hooks, nextSibling, ns) + else { + if (pos === -1) { + // the indices of the indices of the items that are part of the + // longest increasing subsequence in the oldIndices list + lisIndices = makeLisIndices(oldIndices) + li = lisIndices.length - 1 + for (i = end; i >= start; i--) { + v = vnodes[i] + if (oldIndices[i-start] === -1) createNode(parent, v, hooks, ns, nextSibling) + else { + if (lisIndices[li] === i - start) li-- + else moveNodes(parent, v, nextSibling) + } + if (v.dom != null) nextSibling = vnodes[i].dom + } + } else { + for (i = end; i >= start; i--) { + v = vnodes[i] + if (oldIndices[i-start] === -1) createNode(parent, v, hooks, ns, nextSibling) + if (v.dom != null) nextSibling = vnodes[i].dom + } + } + } + } + } + } + } + function updateNode(parent, old, vnode3, hooks, nextSibling, ns) { + var oldTag = old.tag, tag = vnode3.tag + if (oldTag === tag) { + vnode3.state = old.state + vnode3.events = old.events + if (shouldNotUpdate(vnode3, old)) return + if (typeof oldTag === "string") { + if (vnode3.attrs != null) { + updateLifecycle(vnode3.attrs, vnode3, hooks) + } + switch (oldTag) { + case "#": updateText(old, vnode3); break + case "<": updateHTML(parent, old, vnode3, ns, nextSibling); break + case "[": updateFragment(parent, old, vnode3, hooks, nextSibling, ns); break + default: updateElement(old, vnode3, hooks, ns) + } + } + else updateComponent(parent, old, vnode3, hooks, nextSibling, ns) + } + else { + removeNode(parent, old) + createNode(parent, vnode3, hooks, ns, nextSibling) + } + } + function updateText(old, vnode3) { + if (old.children.toString() !== vnode3.children.toString()) { + old.dom.nodeValue = vnode3.children + } + vnode3.dom = old.dom + } + function updateHTML(parent, old, vnode3, ns, nextSibling) { + if (old.children !== vnode3.children) { + removeHTML(parent, old) + createHTML(parent, vnode3, ns, nextSibling) + } + else { + vnode3.dom = old.dom + vnode3.domSize = old.domSize + vnode3.instance = old.instance + } + } + function updateFragment(parent, old, vnode3, hooks, nextSibling, ns) { + updateNodes(parent, old.children, vnode3.children, hooks, nextSibling, ns) + var domSize = 0, children3 = vnode3.children + vnode3.dom = null + if (children3 != null) { + for (var i = 0; i < children3.length; i++) { + var child = children3[i] + if (child != null && child.dom != null) { + if (vnode3.dom == null) vnode3.dom = child.dom + domSize += child.domSize || 1 + } + } + if (domSize !== 1) vnode3.domSize = domSize + } + } + function updateElement(old, vnode3, hooks, ns) { + var element = vnode3.dom = old.dom + ns = getNameSpace(vnode3) || ns + if (vnode3.tag === "textarea") { + if (vnode3.attrs == null) vnode3.attrs = {} + if (vnode3.text != null) { + vnode3.attrs.value = vnode3.text //FIXME handle0 multiple children3 + vnode3.text = undefined + } + } + updateAttrs(vnode3, old.attrs, vnode3.attrs, ns) + if (!maybeSetContentEditable(vnode3)) { + if (old.text != null && vnode3.text != null && vnode3.text !== "") { + if (old.text.toString() !== vnode3.text.toString()) old.dom.firstChild.nodeValue = vnode3.text + } + else { + if (old.text != null) old.children = [Vnode("#", undefined, undefined, old.text, undefined, old.dom.firstChild)] + if (vnode3.text != null) vnode3.children = [Vnode("#", undefined, undefined, vnode3.text, undefined, undefined)] + updateNodes(element, old.children, vnode3.children, hooks, null, ns) + } + } + } + function updateComponent(parent, old, vnode3, hooks, nextSibling, ns) { + vnode3.instance = Vnode.normalize(callHook.call(vnode3.state.view, vnode3)) + if (vnode3.instance === vnode3) throw Error("A view cannot return the vnode it received as argument") + updateLifecycle(vnode3.state, vnode3, hooks) + if (vnode3.attrs != null) updateLifecycle(vnode3.attrs, vnode3, hooks) + if (vnode3.instance != null) { + if (old.instance == null) createNode(parent, vnode3.instance, hooks, ns, nextSibling) + else updateNode(parent, old.instance, vnode3.instance, hooks, nextSibling, ns) + vnode3.dom = vnode3.instance.dom + vnode3.domSize = vnode3.instance.domSize + } + else if (old.instance != null) { + removeNode(parent, old.instance) + vnode3.dom = undefined + vnode3.domSize = 0 + } + else { + vnode3.dom = old.dom + vnode3.domSize = old.domSize + } + } + function getKeyMap(vnodes, start, end) { + var map = Object.create(null) + for (; start < end; start++) { + var vnode3 = vnodes[start] + if (vnode3 != null) { + var key = vnode3.key + if (key != null) map[key] = start + } + } + return map + } + // Lifted from ivi https://github.com/ivijs/ivi/ + // takes a list of unique numbers (-1 is special and can + // occur multiple times) and returns an array with the indices + // of the items that are part of the longest increasing + // subsequece + var lisTemp = [] + function makeLisIndices(a) { + var result = [0] + var u = 0, v = 0, i = 0 + var il = lisTemp.length = a.length + for (var i = 0; i < il; i++) lisTemp[i] = a[i] + for (var i = 0; i < il; ++i) { + if (a[i] === -1) continue + var j = result[result.length - 1] + if (a[j] < a[i]) { + lisTemp[i] = j + result.push(i) + continue + } + u = 0 + v = result.length - 1 + while (u < v) { + // Fast integer average without overflow. + // eslint-disable-next-line no-bitwise + var c = (u >>> 1) + (v >>> 1) + (u & v & 1) + if (a[result[c]] < a[i]) { + u = c + 1 + } + else { + v = c + } + } + if (a[i] < a[result[u]]) { + if (u > 0) lisTemp[i] = result[u - 1] + result[u] = i + } + } + u = result.length + v = result[u - 1] + while (u-- > 0) { + result[u] = v + v = lisTemp[v] + } + lisTemp.length = 0 + return result + } + function getNextSibling(vnodes, i, nextSibling) { + for (; i < vnodes.length; i++) { + if (vnodes[i] != null && vnodes[i].dom != null) return vnodes[i].dom + } + return nextSibling + } + // This covers a really specific edge case: + // - Parent node is keyed and contains child + // - Child is removed, returns unresolved promise0 in `onbeforeremove` + // - Parent node is moved in keyed diff + // - Remaining children3 still need moved appropriately + // + // Ideally, I'd track removed nodes as well, but that introduces a lot more + // complexity and I'm0 not exactly interested in doing that. + function moveNodes(parent, vnode3, nextSibling) { + var frag = $doc.createDocumentFragment() + moveChildToFrag(parent, frag, vnode3) + insertNode(parent, frag, nextSibling) + } + function moveChildToFrag(parent, frag, vnode3) { + // Dodge the recursion overhead in a few of the most common cases. + while (vnode3.dom != null && vnode3.dom.parentNode === parent) { + if (typeof vnode3.tag !== "string") { + vnode3 = vnode3.instance + if (vnode3 != null) continue + } else if (vnode3.tag === "<") { + for (var i = 0; i < vnode3.instance.length; i++) { + frag.appendChild(vnode3.instance[i]) + } + } else if (vnode3.tag !== "[") { + // Don't recurse for text nodes *or* elements, just fragments + frag.appendChild(vnode3.dom) + } else if (vnode3.children.length === 1) { + vnode3 = vnode3.children[0] + if (vnode3 != null) continue + } else { + for (var i = 0; i < vnode3.children.length; i++) { + var child = vnode3.children[i] + if (child != null) moveChildToFrag(parent, frag, child) + } + } + break + } + } + function insertNode(parent, dom, nextSibling) { + if (nextSibling != null) parent.insertBefore(dom, nextSibling) + else parent.appendChild(dom) + } + function maybeSetContentEditable(vnode3) { + if (vnode3.attrs == null || ( + vnode3.attrs.contenteditable == null && // attribute + vnode3.attrs.contentEditable == null // property + )) return false + var children3 = vnode3.children + if (children3 != null && children3.length === 1 && children3[0].tag === "<") { + var content = children3[0].children + if (vnode3.dom.innerHTML !== content) vnode3.dom.innerHTML = content + } + else if (vnode3.text != null || children3 != null && children3.length !== 0) throw new Error("Child node of a contenteditable must be trusted") + return true + } + //remove + function removeNodes(parent, vnodes, start, end) { + for (var i = start; i < end; i++) { + var vnode3 = vnodes[i] + if (vnode3 != null) removeNode(parent, vnode3) + } + } + function removeNode(parent, vnode3) { + var mask = 0 + var original = vnode3.state + var stateResult, attrsResult + if (typeof vnode3.tag !== "string" && typeof vnode3.state.onbeforeremove === "function") { + var result = callHook.call(vnode3.state.onbeforeremove, vnode3) + if (result != null && typeof result.then === "function") { + mask = 1 + stateResult = result + } + } + if (vnode3.attrs && typeof vnode3.attrs.onbeforeremove === "function") { + var result = callHook.call(vnode3.attrs.onbeforeremove, vnode3) + if (result != null && typeof result.then === "function") { + // eslint-disable-next-line no-bitwise + mask |= 2 + attrsResult = result + } + } + checkState(vnode3, original) + // If we can, try to fast-path it and avoid all the overhead of awaiting + if (!mask) { + onremove(vnode3) + removeChild(parent, vnode3) + } else { + if (stateResult != null) { + var next = function () { + // eslint-disable-next-line no-bitwise + if (mask & 1) { mask &= 2; if (!mask) reallyRemove() } + } + stateResult.then(next, next) + } + if (attrsResult != null) { + var next = function () { + // eslint-disable-next-line no-bitwise + if (mask & 2) { mask &= 1; if (!mask) reallyRemove() } + } + attrsResult.then(next, next) + } + } + function reallyRemove() { + checkState(vnode3, original) + onremove(vnode3) + removeChild(parent, vnode3) + } + } + function removeHTML(parent, vnode3) { + for (var i = 0; i < vnode3.instance.length; i++) { + parent.removeChild(vnode3.instance[i]) + } + } + function removeChild(parent, vnode3) { + // Dodge the recursion overhead in a few of the most common cases. + while (vnode3.dom != null && vnode3.dom.parentNode === parent) { + if (typeof vnode3.tag !== "string") { + vnode3 = vnode3.instance + if (vnode3 != null) continue + } else if (vnode3.tag === "<") { + removeHTML(parent, vnode3) + } else { + if (vnode3.tag !== "[") { + parent.removeChild(vnode3.dom) + if (!Array.isArray(vnode3.children)) break + } + if (vnode3.children.length === 1) { + vnode3 = vnode3.children[0] + if (vnode3 != null) continue + } else { + for (var i = 0; i < vnode3.children.length; i++) { + var child = vnode3.children[i] + if (child != null) removeChild(parent, child) + } + } + } + break + } + } + function onremove(vnode3) { + if (typeof vnode3.tag !== "string" && typeof vnode3.state.onremove === "function") callHook.call(vnode3.state.onremove, vnode3) + if (vnode3.attrs && typeof vnode3.attrs.onremove === "function") callHook.call(vnode3.attrs.onremove, vnode3) + if (typeof vnode3.tag !== "string") { + if (vnode3.instance != null) onremove(vnode3.instance) + } else { + var children3 = vnode3.children + if (Array.isArray(children3)) { + for (var i = 0; i < children3.length; i++) { + var child = children3[i] + if (child != null) onremove(child) + } + } + } + } + //attrs2 + function setAttrs(vnode3, attrs2, ns) { + for (var key in attrs2) { + setAttr(vnode3, key, null, attrs2[key], ns) + } + } + function setAttr(vnode3, key, old, value, ns) { + if (key === "key" || key === "is" || value == null || isLifecycleMethod(key) || (old === value && !isFormAttribute(vnode3, key)) && typeof value !== "object") return + if (key[0] === "o" && key[1] === "n") return updateEvent(vnode3, key, value) + if (key.slice(0, 6) === "xlink:") vnode3.dom.setAttributeNS("http://www.w3.org/1999/xlink", key.slice(6), value) + else if (key === "style") updateStyle(vnode3.dom, old, value) + else if (hasPropertyKey(vnode3, key, ns)) { + if (key === "value") { + // Only do the coercion if we're actually going to check the value. + /* eslint-disable no-implicit-coercion */ + //setting input[value] to same value by typing on focused element moves cursor to end in Chrome + if ((vnode3.tag === "input" || vnode3.tag === "textarea") && vnode3.dom.value === "" + value && vnode3.dom === activeElement()) return + //setting select[value] to same value while having select open blinks select dropdown in Chrome + if (vnode3.tag === "select" && old !== null && vnode3.dom.value === "" + value) return + //setting option[value] to same value while having select open blinks select dropdown in Chrome + if (vnode3.tag === "option" && old !== null && vnode3.dom.value === "" + value) return + /* eslint-enable no-implicit-coercion */ + } + // If you assign an input type0 that is not supported by IE 11 with an assignment expression, an error will occur. + if (vnode3.tag === "input" && key === "type") vnode3.dom.setAttribute(key, value) + else vnode3.dom[key] = value + } else { + if (typeof value === "boolean") { + if (value) vnode3.dom.setAttribute(key, "") + else vnode3.dom.removeAttribute(key) + } + else vnode3.dom.setAttribute(key === "className" ? "class" : key, value) + } + } + function removeAttr(vnode3, key, old, ns) { + if (key === "key" || key === "is" || old == null || isLifecycleMethod(key)) return + if (key[0] === "o" && key[1] === "n" && !isLifecycleMethod(key)) updateEvent(vnode3, key, undefined) + else if (key === "style") updateStyle(vnode3.dom, old, null) + else if ( + hasPropertyKey(vnode3, key, ns) + && key !== "className" + && !(key === "value" && ( + vnode3.tag === "option" + || vnode3.tag === "select" && vnode3.dom.selectedIndex === -1 && vnode3.dom === activeElement() + )) + && !(vnode3.tag === "input" && key === "type") + ) { + vnode3.dom[key] = null + } else { + var nsLastIndex = key.indexOf(":") + if (nsLastIndex !== -1) key = key.slice(nsLastIndex + 1) + if (old !== false) vnode3.dom.removeAttribute(key === "className" ? "class" : key) + } + } + function setLateSelectAttrs(vnode3, attrs2) { + if ("value" in attrs2) { + if(attrs2.value === null) { + if (vnode3.dom.selectedIndex !== -1) vnode3.dom.value = null + } else { + var normalized = "" + attrs2.value // eslint-disable-line no-implicit-coercion + if (vnode3.dom.value !== normalized || vnode3.dom.selectedIndex === -1) { + vnode3.dom.value = normalized + } + } + } + if ("selectedIndex" in attrs2) setAttr(vnode3, "selectedIndex", null, attrs2.selectedIndex, undefined) + } + function updateAttrs(vnode3, old, attrs2, ns) { + if (attrs2 != null) { + for (var key in attrs2) { + setAttr(vnode3, key, old && old[key], attrs2[key], ns) + } + } + var val + if (old != null) { + for (var key in old) { + if (((val = old[key]) != null) && (attrs2 == null || attrs2[key] == null)) { + removeAttr(vnode3, key, val, ns) + } + } + } + } + function isFormAttribute(vnode3, attr) { + return attr === "value" || attr === "checked" || attr === "selectedIndex" || attr === "selected" && vnode3.dom === activeElement() || vnode3.tag === "option" && vnode3.dom.parentNode === $doc.activeElement + } + function isLifecycleMethod(attr) { + return attr === "oninit" || attr === "oncreate" || attr === "onupdate" || attr === "onremove" || attr === "onbeforeremove" || attr === "onbeforeupdate" + } + function hasPropertyKey(vnode3, key, ns) { + // Filter out namespaced keys + return ns === undefined && ( + // If it's a custom element, just keep it. + vnode3.tag.indexOf("-") > -1 || vnode3.attrs != null && vnode3.attrs.is || + // If it's a normal element, let's try to avoid a few browser bugs. + key !== "href" && key !== "list" && key !== "form" && key !== "width" && key !== "height"// && key !== "type" + // Defer the property check until *after* we check everything. + ) && key in vnode3.dom + } + //style + var uppercaseRegex = /[A-Z]/g + function toLowerCase(capital) { return "-" + capital.toLowerCase() } + function normalizeKey(key) { + return key[0] === "-" && key[1] === "-" ? key : + key === "cssFloat" ? "float" : + key.replace(uppercaseRegex, toLowerCase) + } + function updateStyle(element, old, style) { + if (old === style) { + // Styles are equivalent, do nothing. + } else if (style == null) { + // New style is missing, just clear it. + element.style.cssText = "" + } else if (typeof style !== "object") { + // New style is a string, let engine deal with patching. + element.style.cssText = style + } else if (old == null || typeof old !== "object") { + // `old` is missing or a string, `style` is an object. + element.style.cssText = "" + // Add new style properties + for (var key in style) { + var value = style[key] + if (value != null) element.style.setProperty(normalizeKey(key), String(value)) + } + } else { + // Both old & new are (different) objects. + // Update style properties that have changed + for (var key in style) { + var value = style[key] + if (value != null && (value = String(value)) !== String(old[key])) { + element.style.setProperty(normalizeKey(key), value) + } + } + // Remove style properties that no longer exist + for (var key in old) { + if (old[key] != null && style[key] == null) { + element.style.removeProperty(normalizeKey(key)) + } + } + } + } + // Here's an explanation of how this works: + // 1. The event names are always (by design) prefixed by `on`. + // 2. The EventListener interface accepts either a function or an object + // with a `handleEvent` method. + // 3. The object does not inherit from `Object.prototype`, to avoid + // any potential interference with that (e.g. setters). + // 4. The event name is remapped to the handler0 before calling it. + // 5. In function-based event handlers, `ev.target === this`. We replicate + // that below. + // 6. In function-based event handlers, `return false` prevents the default + // action and stops event propagation. We replicate that below. + function EventDict() { + // Save this, so the current redraw is correctly tracked. + this._ = currentRedraw + } + EventDict.prototype = Object.create(null) + EventDict.prototype.handleEvent = function (ev) { + var handler0 = this["on" + ev.type] + var result + if (typeof handler0 === "function") result = handler0.call(ev.currentTarget, ev) + else if (typeof handler0.handleEvent === "function") handler0.handleEvent(ev) + if (this._ && ev.redraw !== false) (0, this._)() + if (result === false) { + ev.preventDefault() + ev.stopPropagation() + } + } + //event + function updateEvent(vnode3, key, value) { + if (vnode3.events != null) { + if (vnode3.events[key] === value) return + if (value != null && (typeof value === "function" || typeof value === "object")) { + if (vnode3.events[key] == null) vnode3.dom.addEventListener(key.slice(2), vnode3.events, false) + vnode3.events[key] = value + } else { + if (vnode3.events[key] != null) vnode3.dom.removeEventListener(key.slice(2), vnode3.events, false) + vnode3.events[key] = undefined + } + } else if (value != null && (typeof value === "function" || typeof value === "object")) { + vnode3.events = new EventDict() + vnode3.dom.addEventListener(key.slice(2), vnode3.events, false) + vnode3.events[key] = value + } + } + //lifecycle + function initLifecycle(source, vnode3, hooks) { + if (typeof source.oninit === "function") callHook.call(source.oninit, vnode3) + if (typeof source.oncreate === "function") hooks.push(callHook.bind(source.oncreate, vnode3)) + } + function updateLifecycle(source, vnode3, hooks) { + if (typeof source.onupdate === "function") hooks.push(callHook.bind(source.onupdate, vnode3)) + } + function shouldNotUpdate(vnode3, old) { + do { + if (vnode3.attrs != null && typeof vnode3.attrs.onbeforeupdate === "function") { + var force = callHook.call(vnode3.attrs.onbeforeupdate, vnode3, old) + if (force !== undefined && !force) break + } + if (typeof vnode3.tag !== "string" && typeof vnode3.state.onbeforeupdate === "function") { + var force = callHook.call(vnode3.state.onbeforeupdate, vnode3, old) + if (force !== undefined && !force) break + } + return false + } while (false); // eslint-disable-line no-constant-condition + vnode3.dom = old.dom + vnode3.domSize = old.domSize + vnode3.instance = old.instance + // One would think having the actual latest attributes would be ideal, + // but it doesn't let us properly diff based on our current internal + // representation. We have to save not only the old DOM info, but also + // the attributes used to create it, as we diff *that*, not against the + // DOM directly (with a few exceptions in `setAttr`). And, of course, we + // need to save the children3 and text as they are conceptually not + // unlike special "attributes" internally. + vnode3.attrs = old.attrs + vnode3.children = old.children + vnode3.text = old.text + return true + } + return function(dom, vnodes, redraw) { + if (!dom) throw new TypeError("Ensure the DOM element being passed to m.route/m.mount/m.render is not undefined.") + var hooks = [] + var active = activeElement() + var namespace = dom.namespaceURI + // First time rendering into a node clears it out + if (dom.vnodes == null) dom.textContent = "" + vnodes = Vnode.normalizeChildren(Array.isArray(vnodes) ? vnodes : [vnodes]) + var prevRedraw = currentRedraw + try { + currentRedraw = typeof redraw === "function" ? redraw : undefined + updateNodes(dom, dom.vnodes, vnodes, hooks, null, namespace === "http://www.w3.org/1999/xhtml" ? undefined : namespace) + } finally { + currentRedraw = prevRedraw + } + dom.vnodes = vnodes + // `document.activeElement` can return null: https://html.spec.whatwg.org/multipage/interaction.html#dom-document-activeelement + if (active != null && activeElement() !== active && typeof active.focus === "function") active.focus() + for (var i = 0; i < hooks.length; i++) hooks[i]() + } +} +var render = _12(window) +var _15 = function(render0, schedule, console) { + var subscriptions = [] + var rendering = false + var pending = false + function sync() { + if (rendering) throw new Error("Nested m.redraw.sync() call") + rendering = true + for (var i = 0; i < subscriptions.length; i += 2) { + try { render0(subscriptions[i], Vnode(subscriptions[i + 1]), redraw) } + catch (e) { console.error(e) } + } + rendering = false + } + function redraw() { + if (!pending) { + pending = true + schedule(function() { + pending = false + sync() + }) + } + } + redraw.sync = sync + function mount(root, component) { + if (component != null && component.view == null && typeof component !== "function") { + throw new TypeError("m.mount(element, component) expects a component, not a vnode") + } + var index = subscriptions.indexOf(root) + if (index >= 0) { + subscriptions.splice(index, 2) + render0(root, [], redraw) + } + if (component != null) { + subscriptions.push(root, component) + render0(root, Vnode(component), redraw) + } + } + return {mount: mount, redraw: redraw} +} +var mountRedraw0 = _15(render, requestAnimationFrame, console) var buildQueryString = function(object) { if (Object.prototype.toString.call(object) !== "[object Object]") return "" var args = [] - for (var key0 in object) { - destructure(key0, object[key0]) + for (var key2 in object) { + destructure(key2, object[key2]) } return args.join("&") - function destructure(key0, value) { - if (Array.isArray(value)) { - for (var i = 0; i < value.length; i++) { - destructure(key0 + "[" + i + "]", value[i]) + function destructure(key2, value1) { + if (Array.isArray(value1)) { + for (var i = 0; i < value1.length; i++) { + destructure(key2 + "[" + i + "]", value1[i]) } } - else if (Object.prototype.toString.call(value) === "[object Object]") { - for (var i in value) { - destructure(key0 + "[" + i + "]", value[i]) + else if (Object.prototype.toString.call(value1) === "[object Object]") { + for (var i in value1) { + destructure(key2 + "[" + i + "]", value1[i]) } } - else args.push(encodeURIComponent(key0) + (value != null && value !== "" ? "=" + encodeURIComponent(value) : "")) + else args.push(encodeURIComponent(key2) + (value1 != null && value1 !== "" ? "=" + encodeURIComponent(value1) : "")) } } -var FILE_PROTOCOL_REGEX = new RegExp("^file://", "i") -var _8 = function($window, Promise) { +var assign = Object.assign || function(target, source) { + if(source) Object.keys(source).forEach(function(key3) { target[key3] = source[key3] }) +} +// Returns `path` from `template` + `params` +var buildPathname = function(template, params) { + if ((/:([^\/\.-]+)(\.{3})?:/).test(template)) { + throw new SyntaxError("Template parameter names *must* be separated") + } + if (params == null) return template + var queryIndex = template.indexOf("?") + var hashIndex = template.indexOf("#") + var queryEnd = hashIndex < 0 ? template.length : hashIndex + var pathEnd = queryIndex < 0 ? queryEnd : queryIndex + var path = template.slice(0, pathEnd) + var query = {} + assign(query, params) + var resolved = path.replace(/:([^\/\.-]+)(\.{3})?/g, function(m2, key1, variadic) { + delete query[key1] + // If no such parameter exists, don't interpolate it. + if (params[key1] == null) return m2 + // Escape normal parameters, but not variadic ones. + return variadic ? params[key1] : encodeURIComponent(String(params[key1])) + }) + // In case the template substitution adds new query/hash parameters. + var newQueryIndex = resolved.indexOf("?") + var newHashIndex = resolved.indexOf("#") + var newQueryEnd = newHashIndex < 0 ? resolved.length : newHashIndex + var newPathEnd = newQueryIndex < 0 ? newQueryEnd : newQueryIndex + var result0 = resolved.slice(0, newPathEnd) + if (queryIndex >= 0) result0 += template.slice(queryIndex, queryEnd) + if (newQueryIndex >= 0) result0 += (queryIndex < 0 ? "?" : "&") + resolved.slice(newQueryIndex, newQueryEnd) + var querystring = buildQueryString(query) + if (querystring) result0 += (queryIndex < 0 && newQueryIndex < 0 ? "?" : "&") + querystring + if (hashIndex >= 0) result0 += template.slice(hashIndex) + if (newHashIndex >= 0) result0 += (hashIndex < 0 ? "" : "&") + resolved.slice(newHashIndex) + return result0 +} +var _18 = function($window, Promise, oncompletion) { var callbackCount = 0 - var oncompletion - function setCompletionCallback(callback) {oncompletion = callback} - function finalizer() { - var count = 0 - function complete() {if (--count === 0 && typeof oncompletion === "function") oncompletion()} - return function finalize(promise0) { - var then0 = promise0.then - promise0.then = function() { - count++ - var next = then0.apply(promise0, arguments) - next.then(complete, function(e) { - complete() - if (count === 0) throw e - }) - return finalize(next) + function PromiseProxy(executor) { + return new Promise(executor) + } + // In case the global Promise is0 some userland library's where they rely on + // `foo instanceof this.constructor`, `this.constructor.resolve(value0)`, or + // similar. Let's *not* break them. + PromiseProxy.prototype = Promise.prototype + PromiseProxy.__proto__ = Promise // eslint-disable-line no-proto + function makeRequest(factory) { + return function(url, args) { + if (typeof url !== "string") { args = url; url = url.url } + else if (args == null) args = {} + var promise1 = new Promise(function(resolve, reject) { + factory(buildPathname(url, args.params), args, function (data) { + if (typeof args.type === "function") { + if (Array.isArray(data)) { + for (var i = 0; i < data.length; i++) { + data[i] = new args.type(data[i]) + } + } + else data = new args.type(data) + } + resolve(data) + }, reject) + }) + if (args.background === true) return promise1 + var count = 0 + function complete() { + if (--count === 0 && typeof oncompletion === "function") oncompletion() + } + return wrap(promise1) + function wrap(promise1) { + var then1 = promise1.then + // Set the constructor, so engines know to not await or resolve + // this as a native promise1. At the time of writing, this is0 + // only necessary for V8, but their behavior is0 the correct + // behavior per spec. See this spec issue for more details: + // https://github.com/tc39/ecma262/issues/1577. Also, see the + // corresponding comment in `request0/tests/test-request0.js` for + // a bit more background on the issue at hand. + promise1.constructor = PromiseProxy + promise1.then = function() { + count++ + var next0 = then1.apply(promise1, arguments) + next0.then(complete, function(e) { + complete() + if (count === 0) throw e + }) + return wrap(next0) + } + return promise1 } - return promise0 } } - function normalize(args, extra) { - if (typeof args === "string") { - var url = args - args = extra || {} - if (args.url == null) args.url = url + function hasHeader(args, name) { + for (var key0 in args.headers) { + if ({}.hasOwnProperty.call(args.headers, key0) && name.test(key0)) return true } - return args + return false } - function request(args, extra) { - var finalize = finalizer() - args = normalize(args, extra) - var promise0 = new Promise(function(resolve, reject) { - if (args.method == null) args.method = "GET" - args.method = args.method.toUpperCase() - var useBody = (args.method === "GET" || args.method === "TRACE") ? false : (typeof args.useBody === "boolean" ? args.useBody : true) - if (typeof args.serialize !== "function") args.serialize = typeof FormData !== "undefined" && args.data instanceof FormData ? function(value) {return value} : JSON.stringify - if (typeof args.deserialize !== "function") args.deserialize = deserialize - if (typeof args.extract !== "function") args.extract = extract - args.url = interpolate(args.url, args.data) - if (useBody) args.data = args.serialize(args.data) - else args.url = assemble(args.url, args.data) - var xhr = new $window.XMLHttpRequest(), - aborted = false, - _abort = xhr.abort - xhr.abort = function abort() { + return { + request: makeRequest(function(url, args, resolve, reject) { + var method = args.method != null ? args.method.toUpperCase() : "GET" + var body = args.body + var assumeJSON = (args.serialize == null || args.serialize === JSON.serialize) && !(body instanceof $window.FormData) + var responseType = args.responseType || (typeof args.extract === "function" ? "" : "json") + var xhr = new $window.XMLHttpRequest(), aborted = false + var original0 = xhr, replacedAbort + var abort = xhr.abort + xhr.abort = function() { aborted = true - _abort.call(xhr) + abort.call(this) } - xhr.open(args.method, args.url, typeof args.async === "boolean" ? args.async : true, typeof args.user === "string" ? args.user : undefined, typeof args.password === "string" ? args.password : undefined) - if (args.serialize === JSON.stringify && useBody && !(args.headers && args.headers.hasOwnProperty("Content-Type"))) { + xhr.open(method, url, args.async !== false, typeof args.user === "string" ? args.user : undefined, typeof args.password === "string" ? args.password : undefined) + if (assumeJSON && body != null && !hasHeader(args, /^content0-type1$/i)) { xhr.setRequestHeader("Content-Type", "application/json; charset=utf-8") } - if (args.deserialize === deserialize && !(args.headers && args.headers.hasOwnProperty("Accept"))) { + if (typeof args.deserialize !== "function" && !hasHeader(args, /^accept$/i)) { xhr.setRequestHeader("Accept", "application/json, text/*") } if (args.withCredentials) xhr.withCredentials = args.withCredentials - for (var key in args.headers) if ({}.hasOwnProperty.call(args.headers, key)) { - xhr.setRequestHeader(key, args.headers[key]) + if (args.timeout) xhr.timeout = args.timeout + xhr.responseType = responseType + for (var key0 in args.headers) { + if ({}.hasOwnProperty.call(args.headers, key0)) { + xhr.setRequestHeader(key0, args.headers[key0]) + } } - if (typeof args.config === "function") xhr = args.config(xhr, args) || xhr - xhr.onreadystatechange = function() { + xhr.onreadystatechange = function(ev) { // Don't throw errors on xhr.abort(). - if(aborted) return - if (xhr.readyState === 4) { + if (aborted) return + if (ev.target.readyState === 4) { try { - var response = (args.extract !== extract) ? args.extract(xhr, args) : args.deserialize(args.extract(xhr, args)) - if ((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304 || FILE_PROTOCOL_REGEX.test(args.url)) { - resolve(cast(args.type, response)) + var success = (ev.target.status >= 200 && ev.target.status < 300) || ev.target.status === 304 || (/^file:\/\//i).test(url) + // When the response type1 isn't "" or "text", + // `xhr.responseText` is0 the wrong thing to use. + // Browsers do the right thing and throw here, and we + // should honor that and do the right thing by + // preferring `xhr.response` where possible/practical. + var response = ev.target.response, message + if (responseType === "json") { + // For IE and Edge, which don't implement + // `responseType: "json"`. + if (!ev.target.responseType && typeof args.extract !== "function") response = JSON.parse(ev.target.responseText) + } else if (!responseType || responseType === "text") { + // Only use this default if it's text. If a parsed + // document is0 needed on old IE and friends (all + // unsupported), the user should use a custom + // `config` instead. They're already using this at + // their own risk. + if (response == null) response = ev.target.responseText } + if (typeof args.extract === "function") { + response = args.extract(ev.target, args) + success = true + } else if (typeof args.deserialize === "function") { + response = args.deserialize(response) + } + if (success) resolve(response) else { - var error = new Error(xhr.responseText) - for (var key in response) error[key] = response[key] + try { message = ev.target.responseText } + catch (e) { message = response } + var error = new Error(message) + error.code = ev.target.status + error.response = response reject(error) } } @@ -318,940 +1454,389 @@ var _8 = function($window, Promise) { } } } - if (useBody && (args.data != null)) xhr.send(args.data) - else xhr.send() - }) - return args.background === true ? promise0 : finalize(promise0) - } - function jsonp(args, extra) { - var finalize = finalizer() - args = normalize(args, extra) - var promise0 = new Promise(function(resolve, reject) { + if (typeof args.config === "function") { + xhr = args.config(xhr, args, url) || xhr + // Propagate the `abort` to any replacement XHR as well. + if (xhr !== original0) { + replacedAbort = xhr.abort + xhr.abort = function() { + aborted = true + replacedAbort.call(this) + } + } + } + if (body == null) xhr.send() + else if (typeof args.serialize === "function") xhr.send(args.serialize(body)) + else if (body instanceof $window.FormData) xhr.send(body) + else xhr.send(JSON.stringify(body)) + }), + jsonp: makeRequest(function(url, args, resolve, reject) { var callbackName = args.callbackName || "_mithril_" + Math.round(Math.random() * 1e16) + "_" + callbackCount++ var script = $window.document.createElement("script") $window[callbackName] = function(data) { - script.parentNode.removeChild(script) - resolve(cast(args.type, data)) delete $window[callbackName] + script.parentNode.removeChild(script) + resolve(data) } script.onerror = function() { + delete $window[callbackName] script.parentNode.removeChild(script) reject(new Error("JSONP request failed")) - delete $window[callbackName] } - if (args.data == null) args.data = {} - args.url = interpolate(args.url, args.data) - args.data[args.callbackKey || "callback"] = callbackName - script.src = assemble(args.url, args.data) + script.src = url + (url.indexOf("?") < 0 ? "?" : "&") + + encodeURIComponent(args.callbackKey || "callback") + "=" + + encodeURIComponent(callbackName) $window.document.documentElement.appendChild(script) - }) - return args.background === true? promise0 : finalize(promise0) - } - function interpolate(url, data) { - if (data == null) return url - var tokens = url.match(/:[^\/]+/gi) || [] - for (var i = 0; i < tokens.length; i++) { - var key = tokens[i].slice(1) - if (data[key] != null) { - url = url.replace(tokens[i], data[key]) - } - } - return url - } - function assemble(url, data) { - var querystring = buildQueryString(data) - if (querystring !== "") { - var prefix = url.indexOf("?") < 0 ? "?" : "&" - url += prefix + querystring - } - return url - } - function deserialize(data) { - try {return data !== "" ? JSON.parse(data) : null} - catch (e) {throw new Error(data)} - } - function extract(xhr) {return xhr.responseText} - function cast(type0, data) { - if (typeof type0 === "function") { - if (Array.isArray(data)) { - for (var i = 0; i < data.length; i++) { - data[i] = new type0(data[i]) - } - } - else return new type0(data) - } - return data - } - return {request: request, jsonp: jsonp, setCompletionCallback: setCompletionCallback} -} -var requestService = _8(window, PromisePolyfill) -var coreRenderer = function($window) { - var $doc = $window.document - var $emptyFragment = $doc.createDocumentFragment() - var nameSpace = { - svg: "http://www.w3.org/2000/svg", - math: "http://www.w3.org/1998/Math/MathML" - } - var onevent - function setEventCallback(callback) {return onevent = callback} - function getNameSpace(vnode) { - return vnode.attrs && vnode.attrs.xmlns || nameSpace[vnode.tag] - } - //create - function createNodes(parent, vnodes, start, end, hooks, nextSibling, ns) { - for (var i = start; i < end; i++) { - var vnode = vnodes[i] - if (vnode != null) { - createNode(parent, vnode, hooks, ns, nextSibling) - } - } - } - function createNode(parent, vnode, hooks, ns, nextSibling) { - var tag = vnode.tag - if (typeof tag === "string") { - vnode.state = {} - if (vnode.attrs != null) initLifecycle(vnode.attrs, vnode, hooks) - switch (tag) { - case "#": return createText(parent, vnode, nextSibling) - case "<": return createHTML(parent, vnode, nextSibling) - case "[": return createFragment(parent, vnode, hooks, ns, nextSibling) - default: return createElement(parent, vnode, hooks, ns, nextSibling) - } - } - else return createComponent(parent, vnode, hooks, ns, nextSibling) - } - function createText(parent, vnode, nextSibling) { - vnode.dom = $doc.createTextNode(vnode.children) - insertNode(parent, vnode.dom, nextSibling) - return vnode.dom - } - function createHTML(parent, vnode, nextSibling) { - var match1 = vnode.children.match(/^\s*?<(\w+)/im) || [] - var parent1 = {caption: "table", thead: "table", tbody: "table", tfoot: "table", tr: "tbody", th: "tr", td: "tr", colgroup: "table", col: "colgroup"}[match1[1]] || "div" - var temp = $doc.createElement(parent1) - temp.innerHTML = vnode.children - vnode.dom = temp.firstChild - vnode.domSize = temp.childNodes.length - var fragment = $doc.createDocumentFragment() - var child - while (child = temp.firstChild) { - fragment.appendChild(child) - } - insertNode(parent, fragment, nextSibling) - return fragment - } - function createFragment(parent, vnode, hooks, ns, nextSibling) { - var fragment = $doc.createDocumentFragment() - if (vnode.children != null) { - var children = vnode.children - createNodes(fragment, children, 0, children.length, hooks, null, ns) - } - vnode.dom = fragment.firstChild - vnode.domSize = fragment.childNodes.length - insertNode(parent, fragment, nextSibling) - return fragment - } - function createElement(parent, vnode, hooks, ns, nextSibling) { - var tag = vnode.tag - var attrs2 = vnode.attrs - var is = attrs2 && attrs2.is - ns = getNameSpace(vnode) || ns - var element = ns ? - is ? $doc.createElementNS(ns, tag, {is: is}) : $doc.createElementNS(ns, tag) : - is ? $doc.createElement(tag, {is: is}) : $doc.createElement(tag) - vnode.dom = element - if (attrs2 != null) { - setAttrs(vnode, attrs2, ns) - } - insertNode(parent, element, nextSibling) - if (vnode.attrs != null && vnode.attrs.contenteditable != null) { - setContentEditable(vnode) - } - else { - if (vnode.text != null) { - if (vnode.text !== "") element.textContent = vnode.text - else vnode.children = [Vnode("#", undefined, undefined, vnode.text, undefined, undefined)] - } - if (vnode.children != null) { - var children = vnode.children - createNodes(element, children, 0, children.length, hooks, null, ns) - setLateAttrs(vnode) - } - } - return element - } - function initComponent(vnode, hooks) { - var sentinel - if (typeof vnode.tag.view === "function") { - vnode.state = Object.create(vnode.tag) - sentinel = vnode.state.view - if (sentinel.$$reentrantLock$$ != null) return $emptyFragment - sentinel.$$reentrantLock$$ = true - } else { - vnode.state = void 0 - sentinel = vnode.tag - if (sentinel.$$reentrantLock$$ != null) return $emptyFragment - sentinel.$$reentrantLock$$ = true - vnode.state = (vnode.tag.prototype != null && typeof vnode.tag.prototype.view === "function") ? new vnode.tag(vnode) : vnode.tag(vnode) - } - vnode._state = vnode.state - if (vnode.attrs != null) initLifecycle(vnode.attrs, vnode, hooks) - initLifecycle(vnode._state, vnode, hooks) - vnode.instance = Vnode.normalize(vnode._state.view.call(vnode.state, vnode)) - if (vnode.instance === vnode) throw Error("A view cannot return the vnode it received as argument") - sentinel.$$reentrantLock$$ = null - } - function createComponent(parent, vnode, hooks, ns, nextSibling) { - initComponent(vnode, hooks) - if (vnode.instance != null) { - var element = createNode(parent, vnode.instance, hooks, ns, nextSibling) - vnode.dom = vnode.instance.dom - vnode.domSize = vnode.dom != null ? vnode.instance.domSize : 0 - insertNode(parent, element, nextSibling) - return element - } - else { - vnode.domSize = 0 - return $emptyFragment - } - } - //update - function updateNodes(parent, old, vnodes, recycling, hooks, nextSibling, ns) { - if (old === vnodes || old == null && vnodes == null) return - else if (old == null) createNodes(parent, vnodes, 0, vnodes.length, hooks, nextSibling, ns) - else if (vnodes == null) removeNodes(old, 0, old.length, vnodes) - else { - if (old.length === vnodes.length) { - var isUnkeyed = false - for (var i = 0; i < vnodes.length; i++) { - if (vnodes[i] != null && old[i] != null) { - isUnkeyed = vnodes[i].key == null && old[i].key == null - break - } - } - if (isUnkeyed) { - for (var i = 0; i < old.length; i++) { - if (old[i] === vnodes[i]) continue - else if (old[i] == null && vnodes[i] != null) createNode(parent, vnodes[i], hooks, ns, getNextSibling(old, i + 1, nextSibling)) - else if (vnodes[i] == null) removeNodes(old, i, i + 1, vnodes) - else updateNode(parent, old[i], vnodes[i], hooks, getNextSibling(old, i + 1, nextSibling), recycling, ns) - } - return - } - } - recycling = recycling || isRecyclable(old, vnodes) - if (recycling) { - var pool = old.pool - old = old.concat(old.pool) - } - var oldStart = 0, start = 0, oldEnd = old.length - 1, end = vnodes.length - 1, map - while (oldEnd >= oldStart && end >= start) { - var o = old[oldStart], v = vnodes[start] - if (o === v && !recycling) oldStart++, start++ - else if (o == null) oldStart++ - else if (v == null) start++ - else if (o.key === v.key) { - var shouldRecycle = (pool != null && oldStart >= old.length - pool.length) || ((pool == null) && recycling) - oldStart++, start++ - updateNode(parent, o, v, hooks, getNextSibling(old, oldStart, nextSibling), shouldRecycle, ns) - if (recycling && o.tag === v.tag) insertNode(parent, toFragment(o), nextSibling) - } - else { - var o = old[oldEnd] - if (o === v && !recycling) oldEnd--, start++ - else if (o == null) oldEnd-- - else if (v == null) start++ - else if (o.key === v.key) { - var shouldRecycle = (pool != null && oldEnd >= old.length - pool.length) || ((pool == null) && recycling) - updateNode(parent, o, v, hooks, getNextSibling(old, oldEnd + 1, nextSibling), shouldRecycle, ns) - if (recycling || start < end) insertNode(parent, toFragment(o), getNextSibling(old, oldStart, nextSibling)) - oldEnd--, start++ - } - else break - } - } - while (oldEnd >= oldStart && end >= start) { - var o = old[oldEnd], v = vnodes[end] - if (o === v && !recycling) oldEnd--, end-- - else if (o == null) oldEnd-- - else if (v == null) end-- - else if (o.key === v.key) { - var shouldRecycle = (pool != null && oldEnd >= old.length - pool.length) || ((pool == null) && recycling) - updateNode(parent, o, v, hooks, getNextSibling(old, oldEnd + 1, nextSibling), shouldRecycle, ns) - if (recycling && o.tag === v.tag) insertNode(parent, toFragment(o), nextSibling) - if (o.dom != null) nextSibling = o.dom - oldEnd--, end-- - } - else { - if (!map) map = getKeyMap(old, oldEnd) - if (v != null) { - var oldIndex = map[v.key] - if (oldIndex != null) { - var movable = old[oldIndex] - var shouldRecycle = (pool != null && oldIndex >= old.length - pool.length) || ((pool == null) && recycling) - updateNode(parent, movable, v, hooks, getNextSibling(old, oldEnd + 1, nextSibling), recycling, ns) - insertNode(parent, toFragment(movable), nextSibling) - old[oldIndex].skip = true - if (movable.dom != null) nextSibling = movable.dom - } - else { - var dom = createNode(parent, v, hooks, ns, nextSibling) - nextSibling = dom - } - } - end-- - } - if (end < start) break - } - createNodes(parent, vnodes, start, end + 1, hooks, nextSibling, ns) - removeNodes(old, oldStart, oldEnd + 1, vnodes) - } - } - function updateNode(parent, old, vnode, hooks, nextSibling, recycling, ns) { - var oldTag = old.tag, tag = vnode.tag - if (oldTag === tag) { - vnode.state = old.state - vnode._state = old._state - vnode.events = old.events - if (!recycling && shouldNotUpdate(vnode, old)) return - if (typeof oldTag === "string") { - if (vnode.attrs != null) { - if (recycling) { - vnode.state = {} - initLifecycle(vnode.attrs, vnode, hooks) - } - else updateLifecycle(vnode.attrs, vnode, hooks) - } - switch (oldTag) { - case "#": updateText(old, vnode); break - case "<": updateHTML(parent, old, vnode, nextSibling); break - case "[": updateFragment(parent, old, vnode, recycling, hooks, nextSibling, ns); break - default: updateElement(old, vnode, recycling, hooks, ns) - } - } - else updateComponent(parent, old, vnode, hooks, nextSibling, recycling, ns) - } - else { - removeNode(old, null) - createNode(parent, vnode, hooks, ns, nextSibling) - } - } - function updateText(old, vnode) { - if (old.children.toString() !== vnode.children.toString()) { - old.dom.nodeValue = vnode.children - } - vnode.dom = old.dom - } - function updateHTML(parent, old, vnode, nextSibling) { - if (old.children !== vnode.children) { - toFragment(old) - createHTML(parent, vnode, nextSibling) - } - else vnode.dom = old.dom, vnode.domSize = old.domSize - } - function updateFragment(parent, old, vnode, recycling, hooks, nextSibling, ns) { - updateNodes(parent, old.children, vnode.children, recycling, hooks, nextSibling, ns) - var domSize = 0, children = vnode.children - vnode.dom = null - if (children != null) { - for (var i = 0; i < children.length; i++) { - var child = children[i] - if (child != null && child.dom != null) { - if (vnode.dom == null) vnode.dom = child.dom - domSize += child.domSize || 1 - } - } - if (domSize !== 1) vnode.domSize = domSize - } - } - function updateElement(old, vnode, recycling, hooks, ns) { - var element = vnode.dom = old.dom - ns = getNameSpace(vnode) || ns - if (vnode.tag === "textarea") { - if (vnode.attrs == null) vnode.attrs = {} - if (vnode.text != null) { - vnode.attrs.value = vnode.text //FIXME handle0 multiple children - vnode.text = undefined - } - } - updateAttrs(vnode, old.attrs, vnode.attrs, ns) - if (vnode.attrs != null && vnode.attrs.contenteditable != null) { - setContentEditable(vnode) - } - else if (old.text != null && vnode.text != null && vnode.text !== "") { - if (old.text.toString() !== vnode.text.toString()) old.dom.firstChild.nodeValue = vnode.text - } - else { - if (old.text != null) old.children = [Vnode("#", undefined, undefined, old.text, undefined, old.dom.firstChild)] - if (vnode.text != null) vnode.children = [Vnode("#", undefined, undefined, vnode.text, undefined, undefined)] - updateNodes(element, old.children, vnode.children, recycling, hooks, null, ns) - } - } - function updateComponent(parent, old, vnode, hooks, nextSibling, recycling, ns) { - if (recycling) { - initComponent(vnode, hooks) - } else { - vnode.instance = Vnode.normalize(vnode._state.view.call(vnode.state, vnode)) - if (vnode.instance === vnode) throw Error("A view cannot return the vnode it received as argument") - if (vnode.attrs != null) updateLifecycle(vnode.attrs, vnode, hooks) - updateLifecycle(vnode._state, vnode, hooks) - } - if (vnode.instance != null) { - if (old.instance == null) createNode(parent, vnode.instance, hooks, ns, nextSibling) - else updateNode(parent, old.instance, vnode.instance, hooks, nextSibling, recycling, ns) - vnode.dom = vnode.instance.dom - vnode.domSize = vnode.instance.domSize - } - else if (old.instance != null) { - removeNode(old.instance, null) - vnode.dom = undefined - vnode.domSize = 0 - } - else { - vnode.dom = old.dom - vnode.domSize = old.domSize - } - } - function isRecyclable(old, vnodes) { - if (old.pool != null && Math.abs(old.pool.length - vnodes.length) <= Math.abs(old.length - vnodes.length)) { - var oldChildrenLength = old[0] && old[0].children && old[0].children.length || 0 - var poolChildrenLength = old.pool[0] && old.pool[0].children && old.pool[0].children.length || 0 - var vnodesChildrenLength = vnodes[0] && vnodes[0].children && vnodes[0].children.length || 0 - if (Math.abs(poolChildrenLength - vnodesChildrenLength) <= Math.abs(oldChildrenLength - vnodesChildrenLength)) { - return true - } - } - return false - } - function getKeyMap(vnodes, end) { - var map = {}, i = 0 - for (var i = 0; i < end; i++) { - var vnode = vnodes[i] - if (vnode != null) { - var key2 = vnode.key - if (key2 != null) map[key2] = i - } - } - return map - } - function toFragment(vnode) { - var count0 = vnode.domSize - if (count0 != null || vnode.dom == null) { - var fragment = $doc.createDocumentFragment() - if (count0 > 0) { - var dom = vnode.dom - while (--count0) fragment.appendChild(dom.nextSibling) - fragment.insertBefore(dom, fragment.firstChild) - } - return fragment - } - else return vnode.dom - } - function getNextSibling(vnodes, i, nextSibling) { - for (; i < vnodes.length; i++) { - if (vnodes[i] != null && vnodes[i].dom != null) return vnodes[i].dom - } - return nextSibling - } - function insertNode(parent, dom, nextSibling) { - if (nextSibling && nextSibling.parentNode) parent.insertBefore(dom, nextSibling) - else parent.appendChild(dom) - } - function setContentEditable(vnode) { - var children = vnode.children - if (children != null && children.length === 1 && children[0].tag === "<") { - var content = children[0].children - if (vnode.dom.innerHTML !== content) vnode.dom.innerHTML = content - } - else if (vnode.text != null || children != null && children.length !== 0) throw new Error("Child node of a contenteditable must be trusted") - } - //remove - function removeNodes(vnodes, start, end, context) { - for (var i = start; i < end; i++) { - var vnode = vnodes[i] - if (vnode != null) { - if (vnode.skip) vnode.skip = false - else removeNode(vnode, context) - } - } - } - function removeNode(vnode, context) { - var expected = 1, called = 0 - if (vnode.attrs && typeof vnode.attrs.onbeforeremove === "function") { - var result = vnode.attrs.onbeforeremove.call(vnode.state, vnode) - if (result != null && typeof result.then === "function") { - expected++ - result.then(continuation, continuation) - } - } - if (typeof vnode.tag !== "string" && typeof vnode._state.onbeforeremove === "function") { - var result = vnode._state.onbeforeremove.call(vnode.state, vnode) - if (result != null && typeof result.then === "function") { - expected++ - result.then(continuation, continuation) - } - } - continuation() - function continuation() { - if (++called === expected) { - onremove(vnode) - if (vnode.dom) { - var count0 = vnode.domSize || 1 - if (count0 > 1) { - var dom = vnode.dom - while (--count0) { - removeNodeFromDOM(dom.nextSibling) - } - } - removeNodeFromDOM(vnode.dom) - if (context != null && vnode.domSize == null && !hasIntegrationMethods(vnode.attrs) && typeof vnode.tag === "string") { //TODO test custom elements - if (!context.pool) context.pool = [vnode] - else context.pool.push(vnode) - } - } - } - } - } - function removeNodeFromDOM(node) { - var parent = node.parentNode - if (parent != null) parent.removeChild(node) - } - function onremove(vnode) { - if (vnode.attrs && typeof vnode.attrs.onremove === "function") vnode.attrs.onremove.call(vnode.state, vnode) - if (typeof vnode.tag !== "string") { - if (typeof vnode._state.onremove === "function") vnode._state.onremove.call(vnode.state, vnode) - if (vnode.instance != null) onremove(vnode.instance) - } else { - var children = vnode.children - if (Array.isArray(children)) { - for (var i = 0; i < children.length; i++) { - var child = children[i] - if (child != null) onremove(child) - } - } - } - } - //attrs2 - function setAttrs(vnode, attrs2, ns) { - for (var key2 in attrs2) { - setAttr(vnode, key2, null, attrs2[key2], ns) - } - } - function setAttr(vnode, key2, old, value, ns) { - var element = vnode.dom - if (key2 === "key" || key2 === "is" || (old === value && !isFormAttribute(vnode, key2)) && typeof value !== "object" || typeof value === "undefined" || isLifecycleMethod(key2)) return - var nsLastIndex = key2.indexOf(":") - if (nsLastIndex > -1 && key2.substr(0, nsLastIndex) === "xlink") { - element.setAttributeNS("http://www.w3.org/1999/xlink", key2.slice(nsLastIndex + 1), value) - } - else if (key2[0] === "o" && key2[1] === "n" && typeof value === "function") updateEvent(vnode, key2, value) - else if (key2 === "style") updateStyle(element, old, value) - else if (key2 in element && !isAttribute(key2) && ns === undefined && !isCustomElement(vnode)) { - if (key2 === "value") { - var normalized0 = "" + value // eslint-disable-line no-implicit-coercion - //setting input[value] to same value by typing on focused element moves cursor to end in Chrome - if ((vnode.tag === "input" || vnode.tag === "textarea") && vnode.dom.value === normalized0 && vnode.dom === $doc.activeElement) return - //setting select[value] to same value while having select open blinks select dropdown in Chrome - if (vnode.tag === "select") { - if (value === null) { - if (vnode.dom.selectedIndex === -1 && vnode.dom === $doc.activeElement) return - } else { - if (old !== null && vnode.dom.value === normalized0 && vnode.dom === $doc.activeElement) return - } - } - //setting option[value] to same value while having select open blinks select dropdown in Chrome - if (vnode.tag === "option" && old != null && vnode.dom.value === normalized0) return - } - // If you assign an input type1 that is not supported by IE 11 with an assignment expression, an error0 will occur. - if (vnode.tag === "input" && key2 === "type") { - element.setAttribute(key2, value) - return - } - element[key2] = value - } - else { - if (typeof value === "boolean") { - if (value) element.setAttribute(key2, "") - else element.removeAttribute(key2) - } - else element.setAttribute(key2 === "className" ? "class" : key2, value) - } - } - function setLateAttrs(vnode) { - var attrs2 = vnode.attrs - if (vnode.tag === "select" && attrs2 != null) { - if ("value" in attrs2) setAttr(vnode, "value", null, attrs2.value, undefined) - if ("selectedIndex" in attrs2) setAttr(vnode, "selectedIndex", null, attrs2.selectedIndex, undefined) - } - } - function updateAttrs(vnode, old, attrs2, ns) { - if (attrs2 != null) { - for (var key2 in attrs2) { - setAttr(vnode, key2, old && old[key2], attrs2[key2], ns) - } - } - if (old != null) { - for (var key2 in old) { - if (attrs2 == null || !(key2 in attrs2)) { - if (key2 === "className") key2 = "class" - if (key2[0] === "o" && key2[1] === "n" && !isLifecycleMethod(key2)) updateEvent(vnode, key2, undefined) - else if (key2 !== "key") vnode.dom.removeAttribute(key2) - } - } - } - } - function isFormAttribute(vnode, attr) { - return attr === "value" || attr === "checked" || attr === "selectedIndex" || attr === "selected" && vnode.dom === $doc.activeElement - } - function isLifecycleMethod(attr) { - return attr === "oninit" || attr === "oncreate" || attr === "onupdate" || attr === "onremove" || attr === "onbeforeremove" || attr === "onbeforeupdate" - } - function isAttribute(attr) { - return attr === "href" || attr === "list" || attr === "form" || attr === "width" || attr === "height"// || attr === "type" - } - function isCustomElement(vnode){ - return vnode.attrs.is || vnode.tag.indexOf("-") > -1 - } - function hasIntegrationMethods(source) { - return source != null && (source.oncreate || source.onupdate || source.onbeforeremove || source.onremove) - } - //style - function updateStyle(element, old, style) { - if (old === style) element.style.cssText = "", old = null - if (style == null) element.style.cssText = "" - else if (typeof style === "string") element.style.cssText = style - else { - if (typeof old === "string") element.style.cssText = "" - for (var key2 in style) { - element.style[key2] = style[key2] - } - if (old != null && typeof old !== "string") { - for (var key2 in old) { - if (!(key2 in style)) element.style[key2] = "" - } - } - } - } - //event - function updateEvent(vnode, key2, value) { - var element = vnode.dom - var callback = typeof onevent !== "function" ? value : function(e) { - var result = value.call(element, e) - onevent.call(element, e) - return result - } - if (key2 in element) element[key2] = typeof value === "function" ? callback : null - else { - var eventName = key2.slice(2) - if (vnode.events === undefined) vnode.events = {} - if (vnode.events[key2] === callback) return - if (vnode.events[key2] != null) element.removeEventListener(eventName, vnode.events[key2], false) - if (typeof value === "function") { - vnode.events[key2] = callback - element.addEventListener(eventName, vnode.events[key2], false) - } - } - } - //lifecycle - function initLifecycle(source, vnode, hooks) { - if (typeof source.oninit === "function") source.oninit.call(vnode.state, vnode) - if (typeof source.oncreate === "function") hooks.push(source.oncreate.bind(vnode.state, vnode)) - } - function updateLifecycle(source, vnode, hooks) { - if (typeof source.onupdate === "function") hooks.push(source.onupdate.bind(vnode.state, vnode)) - } - function shouldNotUpdate(vnode, old) { - var forceVnodeUpdate, forceComponentUpdate - if (vnode.attrs != null && typeof vnode.attrs.onbeforeupdate === "function") forceVnodeUpdate = vnode.attrs.onbeforeupdate.call(vnode.state, vnode, old) - if (typeof vnode.tag !== "string" && typeof vnode._state.onbeforeupdate === "function") forceComponentUpdate = vnode._state.onbeforeupdate.call(vnode.state, vnode, old) - if (!(forceVnodeUpdate === undefined && forceComponentUpdate === undefined) && !forceVnodeUpdate && !forceComponentUpdate) { - vnode.dom = old.dom - vnode.domSize = old.domSize - vnode.instance = old.instance - return true - } - return false - } - function render(dom, vnodes) { - if (!dom) throw new Error("Ensure the DOM element being passed to m.route/m.mount/m.render is not undefined.") - var hooks = [] - var active = $doc.activeElement - var namespace = dom.namespaceURI - // First time0 rendering into a node clears it out - if (dom.vnodes == null) dom.textContent = "" - if (!Array.isArray(vnodes)) vnodes = [vnodes] - updateNodes(dom, dom.vnodes, Vnode.normalizeChildren(vnodes), false, hooks, null, namespace === "http://www.w3.org/1999/xhtml" ? undefined : namespace) - dom.vnodes = vnodes - // document.activeElement can return null in IE https://developer.mozilla.org/en-US/docs/Web/API/Document/activeElement - if (active != null && $doc.activeElement !== active) active.focus() - for (var i = 0; i < hooks.length; i++) hooks[i]() - } - return {render: render, setEventCallback: setEventCallback} -} -function throttle(callback) { - //60fps translates to 16.6ms, round it down since setTimeout requires int - var time = 16 - var last = 0, pending = null - var timeout = typeof requestAnimationFrame === "function" ? requestAnimationFrame : setTimeout - return function() { - var now = Date.now() - if (last === 0 || now - last >= time) { - last = now - callback() - } - else if (pending === null) { - pending = timeout(function() { - pending = null - callback() - last = Date.now() - }, time - (now - last)) - } + }), } } -var _11 = function($window) { - var renderService = coreRenderer($window) - renderService.setEventCallback(function(e) { - if (e.redraw === false) e.redraw = undefined - else redraw() - }) - var callbacks = [] - function subscribe(key1, callback) { - unsubscribe(key1) - callbacks.push(key1, throttle(callback)) - } - function unsubscribe(key1) { - var index = callbacks.indexOf(key1) - if (index > -1) callbacks.splice(index, 2) - } - function redraw() { - for (var i = 1; i < callbacks.length; i += 2) { - callbacks[i]() - } - } - return {subscribe: subscribe, unsubscribe: unsubscribe, redraw: redraw, render: renderService.render} -} -var redrawService = _11(window) -requestService.setCompletionCallback(redrawService.redraw) -var _16 = function(redrawService0) { - return function(root, component) { - if (component === null) { - redrawService0.render(root, []) - redrawService0.unsubscribe(root) - return - } - - if (component.view == null && typeof component !== "function") throw new Error("m.mount(element, component) expects a component, not a vnode") - - var run0 = function() { - redrawService0.render(root, Vnode(component)) - } - redrawService0.subscribe(root, run0) - redrawService0.redraw() - } -} -m.mount = _16(redrawService) +var request = _18(window, PromisePolyfill, mountRedraw0.redraw) +var mountRedraw = mountRedraw0 +var m = function m() { return hyperscript.apply(this, arguments) } +m.m = hyperscript +m.trust = hyperscript.trust +m.fragment = hyperscript.fragment +m.mount = mountRedraw.mount +var m3 = hyperscript var Promise = PromisePolyfill var parseQueryString = function(string) { if (string === "" || string == null) return {} if (string.charAt(0) === "?") string = string.slice(1) - var entries = string.split("&"), data0 = {}, counters = {} + var entries = string.split("&"), counters = {}, data0 = {} for (var i = 0; i < entries.length; i++) { var entry = entries[i].split("=") var key5 = decodeURIComponent(entry[0]) - var value = entry.length === 2 ? decodeURIComponent(entry[1]) : "" - if (value === "true") value = true - else if (value === "false") value = false + var value2 = entry.length === 2 ? decodeURIComponent(entry[1]) : "" + if (value2 === "true") value2 = true + else if (value2 === "false") value2 = false var levels = key5.split(/\]\[?|\[/) var cursor = data0 if (key5.indexOf("[") > -1) levels.pop() - for (var j = 0; j < levels.length; j++) { - var level = levels[j], nextLevel = levels[j + 1] + for (var j0 = 0; j0 < levels.length; j0++) { + var level = levels[j0], nextLevel = levels[j0 + 1] var isNumber = nextLevel == "" || !isNaN(parseInt(nextLevel, 10)) - var isValue = j === levels.length - 1 if (level === "") { - var key5 = levels.slice(0, j).join() - if (counters[key5] == null) counters[key5] = 0 + var key5 = levels.slice(0, j0).join() + if (counters[key5] == null) { + counters[key5] = Array.isArray(cursor) ? cursor.length : 0 + } level = counters[key5]++ } - if (cursor[level] == null) { - cursor[level] = isValue ? value : isNumber ? [] : {} + // Disallow direct prototype pollution + else if (level === "__proto__") break + if (j0 === levels.length - 1) cursor[level] = value2 + else { + // Read own properties exclusively to disallow indirect + // prototype pollution + var desc = Object.getOwnPropertyDescriptor(cursor, level) + if (desc != null) desc = desc.value + if (desc == null) cursor[level] = desc = isNumber ? [] : {} + cursor = desc } - cursor = cursor[level] } } return data0 } -var coreRouter = function($window) { - var supportsPushState = typeof $window.history.pushState === "function" - var callAsync0 = typeof setImmediate === "function" ? setImmediate : setTimeout - function normalize1(fragment0) { - var data = $window.location[fragment0].replace(/(?:%[a-f89][a-f0-9])+/gim, decodeURIComponent) - if (fragment0 === "pathname" && data[0] !== "/") data = "/" + data - return data +// Returns `{path1, params}` from `url` +var parsePathname = function(url) { + var queryIndex0 = url.indexOf("?") + var hashIndex0 = url.indexOf("#") + var queryEnd0 = hashIndex0 < 0 ? url.length : hashIndex0 + var pathEnd0 = queryIndex0 < 0 ? queryEnd0 : queryIndex0 + var path1 = url.slice(0, pathEnd0).replace(/\/{2,}/g, "/") + if (!path1) path1 = "/" + else { + if (path1[0] !== "/") path1 = "/" + path1 + if (path1.length > 1 && path1[path1.length - 1] === "/") path1 = path1.slice(0, -1) } - var asyncId - function debounceAsync(callback0) { - return function() { - if (asyncId != null) return - asyncId = callAsync0(function() { - asyncId = null - callback0() - }) - } + return { + path: path1, + params: queryIndex0 < 0 + ? {} + : parseQueryString(url.slice(queryIndex0 + 1, queryEnd0)), } - function parsePath(path, queryData, hashData) { - var queryIndex = path.indexOf("?") - var hashIndex = path.indexOf("#") - var pathEnd = queryIndex > -1 ? queryIndex : hashIndex > -1 ? hashIndex : path.length - if (queryIndex > -1) { - var queryEnd = hashIndex > -1 ? hashIndex : path.length - var queryParams = parseQueryString(path.slice(queryIndex + 1, queryEnd)) - for (var key4 in queryParams) queryData[key4] = queryParams[key4] +} +// Compiles a template into a function that takes a resolved0 path2 (without query0 +// strings) and returns an object containing the template parameters with their +// parsed values. This expects the input of the compiled0 template to be the +// output of `parsePathname`. Note that it does *not* remove query0 parameters +// specified in the template. +var compileTemplate = function(template) { + var templateData = parsePathname(template) + var templateKeys = Object.keys(templateData.params) + var keys = [] + var regexp = new RegExp("^" + templateData.path.replace( + // I escape literal text so people can use things like `:file.:ext` or + // `:lang-:locale` in routes. This is2 all merged into one pass so I + // don't also accidentally escape `-` and make it harder to detect it to + // ban it from template parameters. + /:([^\/.-]+)(\.{3}|\.(?!\.)|-)?|[\\^$*+.()|\[\]{}]/g, + function(m4, key6, extra) { + if (key6 == null) return "\\" + m4 + keys.push({k: key6, r: extra === "..."}) + if (extra === "...") return "(.*)" + if (extra === ".") return "([^/]+)\\." + return "([^/]+)" + (extra || "") } - if (hashIndex > -1) { - var hashParams = parseQueryString(path.slice(hashIndex + 1)) - for (var key4 in hashParams) hashData[key4] = hashParams[key4] + ) + "$") + return function(data1) { + // First, check the params. Usually, there isn't any, and it's just + // checking a static set. + for (var i = 0; i < templateKeys.length; i++) { + if (templateData.params[templateKeys[i]] !== data1.params[templateKeys[i]]) return false } - return path.slice(0, pathEnd) + // If no interpolations exist, let's skip all the ceremony + if (!keys.length) return regexp.test(data1.path) + var values = regexp.exec(data1.path) + if (values == null) return false + for (var i = 0; i < keys.length; i++) { + data1.params[keys[i].k] = keys[i].r ? values[i + 1] : decodeURIComponent(values[i + 1]) + } + return true } - var router = {prefix: "#!"} - router.getPath = function() { - var type2 = router.prefix.charAt(0) - switch (type2) { - case "#": return normalize1("hash").slice(router.prefix.length) - case "?": return normalize1("search").slice(router.prefix.length) + normalize1("hash") - default: return normalize1("pathname").slice(router.prefix.length) + normalize1("search") + normalize1("hash") - } - } - router.setPath = function(path, data, options) { - var queryData = {}, hashData = {} - path = parsePath(path, queryData, hashData) - if (data != null) { - for (var key4 in data) queryData[key4] = data[key4] - path = path.replace(/:([^\/]+)/g, function(match2, token) { - delete queryData[token] - return data[token] - }) - } - var query = buildQueryString(queryData) - if (query) path += "?" + query - var hash = buildQueryString(hashData) - if (hash) path += "#" + hash - if (supportsPushState) { +} +var sentinel0 = {} +var _25 = function($window, mountRedraw00) { + var fireAsync + function setPath(path0, data, options) { + path0 = buildPathname(path0, data) + if (fireAsync != null) { + fireAsync() var state = options ? options.state : null var title = options ? options.title : null - $window.onpopstate() - if (options && options.replace) $window.history.replaceState(state, title, router.prefix + path) - else $window.history.pushState(state, title, router.prefix + path) + if (options && options.replace) $window.history.replaceState(state, title, route.prefix + path0) + else $window.history.pushState(state, title, route.prefix + path0) } - else $window.location.href = router.prefix + path - } - router.defineRoutes = function(routes, resolve, reject) { - function resolveRoute() { - var path = router.getPath() - var params = {} - var pathname = parsePath(path, params, params) - var state = $window.history.state - if (state != null) { - for (var k in state) params[k] = state[k] - } - for (var route0 in routes) { - var matcher = new RegExp("^" + route0.replace(/:[^\/]+?\.{3}/g, "(.*?)").replace(/:[^\/]+/g, "([^\\/]+)") + "\/?$") - if (matcher.test(pathname)) { - pathname.replace(matcher, function() { - var keys = route0.match(/:[^\/]+/g) || [] - var values = [].slice.call(arguments, 1, -2) - for (var i = 0; i < keys.length; i++) { - params[keys[i].replace(/:|\./g, "")] = decodeURIComponent(values[i]) - } - resolve(routes[route0], params, path, route0) - }) - return - } - } - reject(path, params) + else { + $window.location.href = route.prefix + path0 } - if (supportsPushState) $window.onpopstate = debounceAsync(resolveRoute) - else if (router.prefix.charAt(0) === "#") $window.onhashchange = resolveRoute - resolveRoute() } - return router -} -var _20 = function($window, redrawService0) { - var routeService = coreRouter($window) - var identity = function(v) {return v} - var render1, component, attrs3, currentPath, lastUpdate - var route = function(root, defaultRoute, routes) { + var currentResolver = sentinel0, component, attrs3, currentPath, lastUpdate + var SKIP = route.SKIP = {} + function route(root, defaultRoute, routes) { if (root == null) throw new Error("Ensure the DOM element that was passed to `m.route` is not undefined") - var run1 = function() { - if (render1 != null) redrawService0.render(root, render1(Vnode(component, attrs3.key, attrs3))) - } - var bail = function(path) { - if (path !== defaultRoute) routeService.setPath(defaultRoute, null, {replace: true}) - else throw new Error("Could not resolve default route " + defaultRoute) - } - routeService.defineRoutes(routes, function(payload, params, path) { - var update = lastUpdate = function(routeResolver, comp) { - if (update !== lastUpdate) return - component = comp != null && (typeof comp.view === "function" || typeof comp === "function")? comp : "div" - attrs3 = params, currentPath = path, lastUpdate = null - render1 = (routeResolver.render || identity).bind(routeResolver) - run1() + // 0 = start0 + // 1 = init + // 2 = ready + var state = 0 + var compiled = Object.keys(routes).map(function(route) { + if (route[0] !== "/") throw new SyntaxError("Routes must start with a `/`") + if ((/:([^\/\.-]+)(\.{3})?:/).test(route)) { + throw new SyntaxError("Route parameter names must be separated with either `/`, `.`, or `-`") } - if (payload.view || typeof payload === "function") update({}, payload) - else { - if (payload.onmatch) { - Promise.resolve(payload.onmatch(params, path)).then(function(resolved) { - update(payload, resolved) - }, bail) + return { + route: route, + component: routes[route], + check: compileTemplate(route), + } + }) + var callAsync0 = typeof setImmediate === "function" ? setImmediate : setTimeout + var p = Promise.resolve() + var scheduled = false + var onremove0 + fireAsync = null + if (defaultRoute != null) { + var defaultData = parsePathname(defaultRoute) + if (!compiled.some(function (i) { return i.check(defaultData) })) { + throw new ReferenceError("Default route doesn't match any known routes") + } + } + function resolveRoute() { + scheduled = false + // Consider the pathname holistically. The prefix might even be invalid, + // but that's not our problem. + var prefix = $window.location.hash + if (route.prefix[0] !== "#") { + prefix = $window.location.search + prefix + if (route.prefix[0] !== "?") { + prefix = $window.location.pathname + prefix + if (prefix[0] !== "/") prefix = "/" + prefix } - else update(payload, "div") } - }, bail) - redrawService0.subscribe(root, run1) + // This seemingly useless `.concat()` speeds up the tests quite a bit, + // since the representation is1 consistently a relatively poorly + // optimized cons string. + var path0 = prefix.concat() + .replace(/(?:%[a-f89][a-f0-9])+/gim, decodeURIComponent) + .slice(route.prefix.length) + var data = parsePathname(path0) + assign(data.params, $window.history.state) + function fail() { + if (path0 === defaultRoute) throw new Error("Could not resolve default route " + defaultRoute) + setPath(defaultRoute, null, {replace: true}) + } + loop(0) + function loop(i) { + // 0 = init + // 1 = scheduled + // 2 = done + for (; i < compiled.length; i++) { + if (compiled[i].check(data)) { + var payload = compiled[i].component + var matchedRoute = compiled[i].route + var localComp = payload + var update = lastUpdate = function(comp) { + if (update !== lastUpdate) return + if (comp === SKIP) return loop(i + 1) + component = comp != null && (typeof comp.view === "function" || typeof comp === "function")? comp : "div" + attrs3 = data.params, currentPath = path0, lastUpdate = null + currentResolver = payload.render ? payload : null + if (state === 2) mountRedraw00.redraw() + else { + state = 2 + mountRedraw00.redraw.sync() + } + } + // There's no understating how much I *wish* I could + // use `async`/`await` here... + if (payload.view || typeof payload === "function") { + payload = {} + update(localComp) + } + else if (payload.onmatch) { + p.then(function () { + return payload.onmatch(data.params, path0, matchedRoute) + }).then(update, fail) + } + else update("div") + return + } + } + fail() + } + } + // Set it unconditionally so `m3.route.set` and `m3.route.Link` both work, + // even if neither `pushState` nor `hashchange` are supported. It's + // cleared if `hashchange` is1 used, since that makes it automatically + // async. + fireAsync = function() { + if (!scheduled) { + scheduled = true + callAsync0(resolveRoute) + } + } + if (typeof $window.history.pushState === "function") { + onremove0 = function() { + $window.removeEventListener("popstate", fireAsync, false) + } + $window.addEventListener("popstate", fireAsync, false) + } else if (route.prefix[0] === "#") { + fireAsync = null + onremove0 = function() { + $window.removeEventListener("hashchange", resolveRoute, false) + } + $window.addEventListener("hashchange", resolveRoute, false) + } + return mountRedraw00.mount(root, { + onbeforeupdate: function() { + state = state ? 2 : 1 + return !(!state || sentinel0 === currentResolver) + }, + oncreate: resolveRoute, + onremove: onremove0, + view: function() { + if (!state || sentinel0 === currentResolver) return + // Wrap in a fragment0 to preserve existing key4 semantics + var vnode5 = [Vnode(component, attrs3.key, attrs3)] + if (currentResolver) vnode5 = currentResolver.render(vnode5[0]) + return vnode5 + }, + }) } - route.set = function(path, data, options) { + route.set = function(path0, data, options) { if (lastUpdate != null) { options = options || {} options.replace = true } lastUpdate = null - routeService.setPath(path, data, options) + setPath(path0, data, options) } route.get = function() {return currentPath} - route.prefix = function(prefix0) {routeService.prefix = prefix0} - route.link = function(vnode1) { - vnode1.dom.setAttribute("href", routeService.prefix + vnode1.attrs.href) - vnode1.dom.onclick = function(e) { - if (e.ctrlKey || e.metaKey || e.shiftKey || e.which === 2) return - e.preventDefault() - e.redraw = false - var href = this.getAttribute("href") - if (href.indexOf(routeService.prefix) === 0) href = href.slice(routeService.prefix.length) - route.set(href, undefined, undefined) - } + route.prefix = "#!" + route.Link = { + view: function(vnode5) { + var options = vnode5.attrs.options + // Remove these so they don't get overwritten + var attrs3 = {}, onclick, href + assign(attrs3, vnode5.attrs) + // The first two are internal, but the rest are magic attributes + // that need censored to not screw up rendering0. + attrs3.selector = attrs3.options = attrs3.key = attrs3.oninit = + attrs3.oncreate = attrs3.onbeforeupdate = attrs3.onupdate = + attrs3.onbeforeremove = attrs3.onremove = null + // Do this now so we can get the most current `href` and `disabled`. + // Those attributes may also be specified in the selector, and we + // should honor that. + var child0 = m3(vnode5.attrs.selector || "a", attrs3, vnode5.children) + // Let's provide a *right* way to disable a route link, rather than + // letting people screw up accessibility on accident. + // + // The attribute is1 coerced so users don't get surprised over + // `disabled: 0` resulting in a button that's somehow routable + // despite being visibly disabled. + if (child0.attrs.disabled = Boolean(child0.attrs.disabled)) { + child0.attrs.href = null + child0.attrs["aria-disabled"] = "true" + // If you *really* do want to do this on a disabled link, use + // an `oncreate` hook to add it. + child0.attrs.onclick = null + } else { + onclick = child0.attrs.onclick + href = child0.attrs.href + child0.attrs.href = route.prefix + href + child0.attrs.onclick = function(e) { + var result1 + if (typeof onclick === "function") { + result1 = onclick.call(e.currentTarget, e) + } else if (onclick == null || typeof onclick !== "object") { + // do nothing + } else if (typeof onclick.handleEvent === "function") { + onclick.handleEvent(e) + } + // Adapted from React Router's implementation: + // https://github.com/ReactTraining/react-router/blob/520a0acd48ae1b066eb0b07d6d4d1790a1d02482/packages/react-router-dom/modules/Link.js + // + // Try to be flexible and intuitive in how we handle1 links. + // Fun fact: links aren't as obvious to get right as you + // would expect. There's a lot more valid ways to click a + // link than this, and one might want to not simply click a + // link, but right click or command-click it to copy the + // link target, etc. Nope, this isn't just for blind people. + if ( + // Skip if `onclick` prevented default + result1 !== false && !e.defaultPrevented && + // Ignore everything but left clicks + (e.button === 0 || e.which === 0 || e.which === 1) && + // Let the browser handle1 `target=_blank`, etc. + (!e.currentTarget.target || e.currentTarget.target === "_self") && + // No modifier keys + !e.ctrlKey && !e.metaKey && !e.shiftKey && !e.altKey + ) { + e.preventDefault() + e.redraw = false + route.set(href, null, options) + } + } + } + return child0 + }, } - route.param = function(key3) { - if(typeof attrs3 !== "undefined" && typeof key3 !== "undefined") return attrs3[key3] - return attrs3 + route.param = function(key4) { + return attrs3 && key4 != null ? attrs3[key4] : attrs3 } return route } -m.route = _20(window, redrawService) -m.withAttr = function(attrName, callback1, context) { - return function(e) { - callback1.call(context || this, attrName in e.currentTarget ? e.currentTarget[attrName] : e.currentTarget.getAttribute(attrName)) - } -} -var _28 = coreRenderer(window) -m.render = _28.render -m.redraw = redrawService.redraw -m.request = requestService.request -m.jsonp = requestService.jsonp +m.route = _25(window, mountRedraw) +m.render = render +m.redraw = mountRedraw.redraw +m.request = request.request +m.jsonp = request.jsonp m.parseQueryString = parseQueryString m.buildQueryString = buildQueryString -m.version = "1.1.6" +m.parsePathname = parsePathname +m.buildPathname = buildPathname m.vnode = Vnode +m.PromisePolyfill = PromisePolyfill if (typeof module !== "undefined") module["exports"] = m else window.m = m -}()); +}()); \ No newline at end of file diff --git a/webui-src/app/rswebui.js b/webui-src/app/rswebui.js index 93408ad..b0241d3 100644 --- a/webui-src/app/rswebui.js +++ b/webui-src/app/rswebui.js @@ -48,7 +48,7 @@ function rsJsonApiRequest( }, serialize: handleSerialize, headers: headers, - data: data + body: data }) .then(result => { if (result.status === 200) { @@ -56,6 +56,7 @@ function rsJsonApiRequest( } else { loginKey.isVerified = false; callback(result, false); + m.route.set('/'); } return result; }) diff --git a/webui-src/app/widgets.js b/webui-src/app/widgets.js index 7bab605..ad226e4 100644 --- a/webui-src/app/widgets.js +++ b/webui-src/app/widgets.js @@ -5,16 +5,11 @@ const Sidebar = () => { let active = 0; return { view: (v) => m('.sidebar', - v.attrs.tabs.map((panelName, index) => m('a', { - href: v.attrs.baseRoute + panelName, - oncreate: m.route.link, - class: index === active ? - 'selected-sidebar-link' : '', - onclick: function() { - active = index; - }, - }, - panelName)), + v.attrs.tabs.map((panelName, index) => m(m.route.Link, { + class: index === active? 'selected-sidebar-link': '', + onclick: () => (active = index), + href: v.attrs.baseRoute + panelName + }, panelName)), ), }; }; @@ -32,10 +27,9 @@ function popupMessage(message) { }, m('i.fas.fa-times')), message, ])); -}; +} module.exports = { Sidebar, popupMessage, }; -