Add meta description to docs
This commit is contained in:
Stephan Hoyer
parent
c7b56161a5
commit
7b1fda5b66
47 changed files with 540 additions and 267 deletions
597
mithril.js
597
mithril.js
|
|
@ -1,7 +1,7 @@
|
|||
;(function() {
|
||||
"use strict"
|
||||
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}
|
||||
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, events: undefined, instance: undefined}
|
||||
}
|
||||
Vnode.normalize = function(node) {
|
||||
if (Array.isArray(node)) return Vnode("[", undefined, undefined, Vnode.normalizeChildren(node), undefined, undefined)
|
||||
|
|
@ -10,7 +10,7 @@ Vnode.normalize = function(node) {
|
|||
return Vnode("#", undefined, undefined, String(node), undefined, undefined)
|
||||
}
|
||||
Vnode.normalizeChildren = function(input) {
|
||||
var children0 = []
|
||||
var children = []
|
||||
if (input.length) {
|
||||
var isKeyed = input[0] != null && input[0].key != null
|
||||
// Note: this is a *very* perf-sensitive check.
|
||||
|
|
@ -18,14 +18,18 @@ Vnode.normalizeChildren = function(input) {
|
|||
// 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!")
|
||||
throw new TypeError(
|
||||
isKeyed && (input[i] != null || typeof input[i] === "boolean")
|
||||
? "In fragments, vnodes must either all have keys or none have keys. You may wish to consider using an explicit keyed empty fragment, m.fragment({key: ...}), instead of a hole."
|
||||
: "In fragments, vnodes must either all have keys or none have keys."
|
||||
)
|
||||
}
|
||||
}
|
||||
for (var i = 0; i < input.length; i++) {
|
||||
children0[i] = Vnode.normalize(input[i])
|
||||
children[i] = Vnode.normalize(input[i])
|
||||
}
|
||||
}
|
||||
return children0
|
||||
return children
|
||||
}
|
||||
// Call via `hyperscriptVnode0.apply(startOffset, arguments)`
|
||||
//
|
||||
|
|
@ -45,19 +49,19 @@ Vnode.normalizeChildren = function(input) {
|
|||
// 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) {
|
||||
// var hyperscriptVnode = function(attrs1, ...children0) {
|
||||
// if (attrs1 == null || typeof attrs1 === "object" && attrs1.tag == null && !Array.isArray(attrs1)) {
|
||||
// if (children1.length === 1 && Array.isArray(children1[0])) children1 = children1[0]
|
||||
// if (children0.length === 1 && Array.isArray(children0[0])) children0 = children0[0]
|
||||
// } else {
|
||||
// children1 = children1.length === 0 && Array.isArray(attrs1) ? attrs1 : [attrs1, ...children1]
|
||||
// children0 = children0.length === 0 && Array.isArray(attrs1) ? attrs1 : [attrs1, ...children0]
|
||||
// attrs1 = undefined
|
||||
// }
|
||||
//
|
||||
// if (attrs1 == null) attrs1 = {}
|
||||
// return Vnode("", attrs1.key, attrs1, children1)
|
||||
// return Vnode("", attrs1.key, attrs1, children0)
|
||||
// }
|
||||
var hyperscriptVnode = function() {
|
||||
var attrs1 = arguments[this], start = this + 1, children1
|
||||
var attrs1 = arguments[this], start = this + 1, children0
|
||||
if (attrs1 == null) {
|
||||
attrs1 = {}
|
||||
} else if (typeof attrs1 !== "object" || attrs1.tag != null || Array.isArray(attrs1)) {
|
||||
|
|
@ -65,17 +69,18 @@ var hyperscriptVnode = function() {
|
|||
start = this
|
||||
}
|
||||
if (arguments.length === start + 1) {
|
||||
children1 = arguments[start]
|
||||
if (!Array.isArray(children1)) children1 = [children1]
|
||||
children0 = arguments[start]
|
||||
if (!Array.isArray(children0)) children0 = [children0]
|
||||
} else {
|
||||
children1 = []
|
||||
while (start < arguments.length) children1.push(arguments[start++])
|
||||
children0 = []
|
||||
while (start < arguments.length) children0.push(arguments[start++])
|
||||
}
|
||||
return Vnode("", attrs1.key, attrs1, children1)
|
||||
return Vnode("", attrs1.key, attrs1, children0)
|
||||
}
|
||||
// This exists so I'm1 only saving it once.
|
||||
var hasOwn = {}.hasOwnProperty
|
||||
var selectorParser = /(?:(^|#|\.)([^#\.\[\]]+))|(\[(.+?)(?:\s*=\s*("|'|)((?:\\["'\]]|.)*?)\5)?\])/g
|
||||
var selectorCache = {}
|
||||
var hasOwn = {}.hasOwnProperty
|
||||
function isEmpty(object) {
|
||||
for (var key in object) if (hasOwn.call(object, key)) return false
|
||||
return true
|
||||
|
|
@ -99,12 +104,10 @@ function compileSelector(selector) {
|
|||
}
|
||||
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
|
||||
vnode.attrs = {}
|
||||
if (!isEmpty(state.attrs) && !isEmpty(attrs)) {
|
||||
var newAttrs = {}
|
||||
for (var key in attrs) {
|
||||
|
|
@ -132,11 +135,6 @@ function execSelector(state, vnode) {
|
|||
break
|
||||
}
|
||||
}
|
||||
if (Array.isArray(children) && children.length === 1 && children[0] != null && children[0].tag === "#") {
|
||||
vnode.text = children[0].children
|
||||
} else {
|
||||
vnode.children = children
|
||||
}
|
||||
return vnode
|
||||
}
|
||||
function hyperscript(selector) {
|
||||
|
|
@ -161,10 +159,11 @@ hyperscript.fragment = function() {
|
|||
vnode2.children = Vnode.normalizeChildren(vnode2.children)
|
||||
return vnode2
|
||||
}
|
||||
/* global window */
|
||||
/** @constructor */
|
||||
var PromisePolyfill = function(executor) {
|
||||
if (!(this instanceof PromisePolyfill)) throw new Error("Promise must be called with `new`")
|
||||
if (typeof executor !== "function") throw new TypeError("executor must be a function")
|
||||
if (!(this instanceof PromisePolyfill)) throw new Error("Promise must be called with 'new'.")
|
||||
if (typeof executor !== "function") throw new TypeError("executor must be a function.")
|
||||
var self = this, resolvers = [], rejectors = [], resolveCurrent = handler(resolvers, true), rejectCurrent = handler(rejectors, false)
|
||||
var instance = self._instance = {resolvers: resolvers, rejectors: rejectors}
|
||||
var callAsync = typeof setImmediate === "function" ? setImmediate : setTimeout
|
||||
|
|
@ -173,7 +172,7 @@ var PromisePolyfill = function(executor) {
|
|||
var then
|
||||
try {
|
||||
if (shouldAbsorb && value != null && (typeof value === "object" || typeof value === "function") && typeof (then = value.then) === "function") {
|
||||
if (value === self) throw new TypeError("Promise can't be resolved w/ itself")
|
||||
if (value === self) throw new TypeError("Promise can't be resolved with itself.")
|
||||
executeOnce(then.bind(value))
|
||||
}
|
||||
else {
|
||||
|
|
@ -284,7 +283,7 @@ if (typeof window !== "undefined") {
|
|||
var PromisePolyfill = global.Promise
|
||||
} else {
|
||||
}
|
||||
var _12 = function($window) {
|
||||
var _13 = function($window) {
|
||||
var $doc = $window && $window.document
|
||||
var currentRedraw
|
||||
var nameSpace = {
|
||||
|
|
@ -296,7 +295,7 @@ var _12 = function($window) {
|
|||
}
|
||||
//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")
|
||||
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
|
||||
|
|
@ -376,8 +375,8 @@ var _12 = function($window) {
|
|||
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)
|
||||
var children2 = vnode3.children
|
||||
createNodes(fragment, children2, 0, children2.length, hooks, null, ns)
|
||||
}
|
||||
vnode3.dom = fragment.firstChild
|
||||
vnode3.domSize = fragment.childNodes.length
|
||||
|
|
@ -397,13 +396,9 @@ var _12 = function($window) {
|
|||
}
|
||||
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)
|
||||
var children2 = vnode3.children
|
||||
createNodes(element, children2, 0, children2.length, hooks, null, ns)
|
||||
if (vnode3.tag === "select" && attrs2 != null) setLateSelectAttrs(vnode3, attrs2)
|
||||
}
|
||||
}
|
||||
|
|
@ -548,7 +543,6 @@ var _12 = function($window) {
|
|||
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)
|
||||
|
|
@ -707,11 +701,11 @@ var _12 = function($window) {
|
|||
}
|
||||
function updateFragment(parent, old, vnode3, hooks, nextSibling, ns) {
|
||||
updateNodes(parent, old.children, vnode3.children, hooks, nextSibling, ns)
|
||||
var domSize = 0, children3 = vnode3.children
|
||||
var domSize = 0, children2 = vnode3.children
|
||||
vnode3.dom = null
|
||||
if (children3 != null) {
|
||||
for (var i = 0; i < children3.length; i++) {
|
||||
var child = children3[i]
|
||||
if (children2 != null) {
|
||||
for (var i = 0; i < children2.length; i++) {
|
||||
var child = children2[i]
|
||||
if (child != null && child.dom != null) {
|
||||
if (vnode3.dom == null) vnode3.dom = child.dom
|
||||
domSize += child.domSize || 1
|
||||
|
|
@ -725,21 +719,10 @@ var _12 = function($window) {
|
|||
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)
|
||||
}
|
||||
updateNodes(element, old.children, vnode3.children, hooks, null, ns)
|
||||
}
|
||||
}
|
||||
function updateComponent(parent, old, vnode3, hooks, nextSibling, ns) {
|
||||
|
|
@ -830,10 +813,10 @@ var _12 = function($window) {
|
|||
// - 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
|
||||
// - Remaining children2 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.
|
||||
// complexity and I'm2 not exactly interested in doing that.
|
||||
function moveNodes(parent, vnode3, nextSibling) {
|
||||
var frag = $doc.createDocumentFragment()
|
||||
moveChildToFrag(parent, frag, vnode3)
|
||||
|
|
@ -873,12 +856,12 @@ var _12 = function($window) {
|
|||
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
|
||||
var children2 = vnode3.children
|
||||
if (children2 != null && children2.length === 1 && children2[0].tag === "<") {
|
||||
var content = children2[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")
|
||||
else if (children2 != null && children2.length !== 0) throw new Error("Child node of a contenteditable must be trusted.")
|
||||
return true
|
||||
}
|
||||
//remove
|
||||
|
|
@ -971,10 +954,10 @@ var _12 = function($window) {
|
|||
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]
|
||||
var children2 = vnode3.children
|
||||
if (Array.isArray(children2)) {
|
||||
for (var i = 0; i < children2.length; i++) {
|
||||
var child = children2[i]
|
||||
if (child != null) onremove(child)
|
||||
}
|
||||
}
|
||||
|
|
@ -982,12 +965,18 @@ var _12 = function($window) {
|
|||
}
|
||||
//attrs2
|
||||
function setAttrs(vnode3, attrs2, ns) {
|
||||
// If you assign an input type0 that is not supported by IE 11 with an assignment expression, an error will occur.
|
||||
//
|
||||
// Also, the DOM does things to inputs based on the value, so it needs set first.
|
||||
// See: https://github.com/MithrilJS/mithril.js/issues/2622
|
||||
if (vnode3.tag === "input" && attrs2.type != null) vnode3.dom.setAttribute("type", attrs2.type)
|
||||
var isFileInput = attrs2 != null && vnode3.tag === "input" && attrs2.type === "file"
|
||||
for (var key in attrs2) {
|
||||
setAttr(vnode3, key, null, attrs2[key], ns)
|
||||
setAttr(vnode3, key, null, attrs2[key], ns, isFileInput)
|
||||
}
|
||||
}
|
||||
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
|
||||
function setAttr(vnode3, key, old, value, ns, isFileInput) {
|
||||
if (key === "key" || key === "is" || value == null || isLifecycleMethod(key) || (old === value && !isFormAttribute(vnode3, key)) && typeof value !== "object" || key === "type" && vnode3.tag === "input") 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)
|
||||
|
|
@ -996,16 +985,18 @@ var _12 = function($window) {
|
|||
// 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 input[type0=file][value] to same value causes an error to be generated if it's non-empty
|
||||
if ((vnode3.tag === "input" || vnode3.tag === "textarea") && vnode3.dom.value === "" + value && (isFileInput || 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
|
||||
//setting input[type0=file][value] to different value is an error if it's non-empty
|
||||
// Not ideal, but it at least works around the most common source of uncaught exceptions for now.
|
||||
if (isFileInput && "" + value !== "") { console.error("`value` is read-only on file inputs!"); 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
|
||||
vnode3.dom[key] = value
|
||||
} else {
|
||||
if (typeof value === "boolean") {
|
||||
if (value) vnode3.dom.setAttribute(key, "")
|
||||
|
|
@ -1016,11 +1007,12 @@ var _12 = function($window) {
|
|||
}
|
||||
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)
|
||||
if (key[0] === "o" && key[1] === "n") updateEvent(vnode3, key, undefined)
|
||||
else if (key === "style") updateStyle(vnode3.dom, old, null)
|
||||
else if (
|
||||
hasPropertyKey(vnode3, key, ns)
|
||||
&& key !== "className"
|
||||
&& key !== "title" // creates "null" as title
|
||||
&& !(key === "value" && (
|
||||
vnode3.tag === "option"
|
||||
|| vnode3.tag === "select" && vnode3.dom.selectedIndex === -1 && vnode3.dom === activeElement()
|
||||
|
|
@ -1048,9 +1040,18 @@ var _12 = function($window) {
|
|||
if ("selectedIndex" in attrs2) setAttr(vnode3, "selectedIndex", null, attrs2.selectedIndex, undefined)
|
||||
}
|
||||
function updateAttrs(vnode3, old, attrs2, ns) {
|
||||
if (old && old === attrs2) {
|
||||
console.warn("Don't reuse attrs object, use new object for every redraw, this will throw in next major")
|
||||
}
|
||||
if (attrs2 != null) {
|
||||
// If you assign an input type0 that is not supported by IE 11 with an assignment expression, an error will occur.
|
||||
//
|
||||
// Also, the DOM does things to inputs based on the value, so it needs set first.
|
||||
// See: https://github.com/MithrilJS/mithril.js/issues/2622
|
||||
if (vnode3.tag === "input" && attrs2.type != null) vnode3.dom.setAttribute("type", attrs2.type)
|
||||
var isFileInput = vnode3.tag === "input" && attrs2.type === "file"
|
||||
for (var key in attrs2) {
|
||||
setAttr(vnode3, key, old && old[key], attrs2[key], ns)
|
||||
setAttr(vnode3, key, old && old[key], attrs2[key], ns, isFileInput)
|
||||
}
|
||||
}
|
||||
var val
|
||||
|
|
@ -1150,6 +1151,7 @@ var _12 = function($window) {
|
|||
//event
|
||||
function updateEvent(vnode3, key, value) {
|
||||
if (vnode3.events != null) {
|
||||
vnode3.events._ = currentRedraw
|
||||
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)
|
||||
|
|
@ -1192,47 +1194,52 @@ var _12 = function($window) {
|
|||
// 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
|
||||
// need to save the children2 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
|
||||
}
|
||||
var currentDOM
|
||||
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.")
|
||||
if (!dom) throw new TypeError("DOM element being rendered to does not exist.")
|
||||
if (currentDOM != null && dom.contains(currentDOM)) {
|
||||
throw new TypeError("Node is currently being rendered to and thus is locked.")
|
||||
}
|
||||
var prevRedraw = currentRedraw
|
||||
var prevDOM = currentDOM
|
||||
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
|
||||
currentDOM = dom
|
||||
currentRedraw = typeof redraw === "function" ? redraw : undefined
|
||||
try {
|
||||
currentRedraw = typeof redraw === "function" ? redraw : undefined
|
||||
// First time rendering into a node clears it out
|
||||
if (dom.vnodes == null) dom.textContent = ""
|
||||
vnodes = Vnode.normalizeChildren(Array.isArray(vnodes) ? vnodes : [vnodes])
|
||||
updateNodes(dom, dom.vnodes, vnodes, hooks, null, namespace === "http://www.w3.org/1999/xhtml" ? undefined : namespace)
|
||||
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]()
|
||||
} finally {
|
||||
currentRedraw = prevRedraw
|
||||
currentDOM = prevDOM
|
||||
}
|
||||
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 render = _13(typeof window !== "undefined" ? window : null)
|
||||
var _16 = function(render0, schedule, console) {
|
||||
var subscriptions = []
|
||||
var rendering = false
|
||||
var pending = false
|
||||
var offset = -1
|
||||
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) }
|
||||
for (offset = 0; offset < subscriptions.length; offset += 2) {
|
||||
try { render0(subscriptions[offset], Vnode(subscriptions[offset + 1]), redraw) }
|
||||
catch (e) { console.error(e) }
|
||||
}
|
||||
rendering = false
|
||||
offset = -1
|
||||
}
|
||||
function redraw() {
|
||||
if (!pending) {
|
||||
|
|
@ -1246,12 +1253,13 @@ var _15 = function(render0, schedule, console) {
|
|||
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")
|
||||
throw new TypeError("m.mount expects a component, not a vnode.")
|
||||
}
|
||||
var index = subscriptions.indexOf(root)
|
||||
if (index >= 0) {
|
||||
subscriptions.splice(index, 2)
|
||||
render0(root, [], redraw)
|
||||
if (index <= offset) offset -= 2
|
||||
render0(root, [])
|
||||
}
|
||||
if (component != null) {
|
||||
subscriptions.push(root, component)
|
||||
|
|
@ -1260,7 +1268,7 @@ var _15 = function(render0, schedule, console) {
|
|||
}
|
||||
return {mount: mount, redraw: redraw}
|
||||
}
|
||||
var mountRedraw0 = _15(render, requestAnimationFrame, console)
|
||||
var mountRedraw0 = _16(render, typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : null, typeof console !== "undefined" ? console : null)
|
||||
var buildQueryString = function(object) {
|
||||
if (Object.prototype.toString.call(object) !== "[object Object]") return ""
|
||||
var args = []
|
||||
|
|
@ -1282,13 +1290,16 @@ var buildQueryString = function(object) {
|
|||
else args.push(encodeURIComponent(key2) + (value1 != null && value1 !== "" ? "=" + encodeURIComponent(value1) : ""))
|
||||
}
|
||||
}
|
||||
// This exists so I'm5 only saving it once.
|
||||
var assign = Object.assign || function(target, source) {
|
||||
if(source) Object.keys(source).forEach(function(key3) { target[key3] = source[key3] })
|
||||
for (var key3 in source) {
|
||||
if (hasOwn.call(source, 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")
|
||||
throw new SyntaxError("Template parameter names must be separated by either a '/', '-', or '.'.")
|
||||
}
|
||||
if (params == null) return template
|
||||
var queryIndex = template.indexOf("?")
|
||||
|
|
@ -1298,10 +1309,10 @@ var buildPathname = function(template, params) {
|
|||
var path = template.slice(0, pathEnd)
|
||||
var query = {}
|
||||
assign(query, params)
|
||||
var resolved = path.replace(/:([^\/\.-]+)(\.{3})?/g, function(m2, key1, variadic) {
|
||||
var resolved = path.replace(/:([^\/\.-]+)(\.{3})?/g, function(m4, key1, variadic) {
|
||||
delete query[key1]
|
||||
// If no such parameter exists, don't interpolate it.
|
||||
if (params[key1] == null) return m2
|
||||
if (params[key1] == null) return m4
|
||||
// Escape normal parameters, but not variadic ones.
|
||||
return variadic ? params[key1] : encodeURIComponent(String(params[key1]))
|
||||
})
|
||||
|
|
@ -1319,7 +1330,7 @@ var buildPathname = function(template, params) {
|
|||
if (newHashIndex >= 0) result0 += (hashIndex < 0 ? "" : "&") + resolved.slice(newHashIndex)
|
||||
return result0
|
||||
}
|
||||
var _18 = function($window, Promise, oncompletion) {
|
||||
var _19 = function($window, Promise, oncompletion) {
|
||||
var callbackCount = 0
|
||||
function PromiseProxy(executor) {
|
||||
return new Promise(executor)
|
||||
|
|
@ -1377,7 +1388,7 @@ var _18 = function($window, Promise, oncompletion) {
|
|||
}
|
||||
function hasHeader(args, name) {
|
||||
for (var key0 in args.headers) {
|
||||
if ({}.hasOwnProperty.call(args.headers, key0) && name.test(key0)) return true
|
||||
if (hasOwn.call(args.headers, key0) && key0.toLowerCase() === name) return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
|
@ -1385,9 +1396,9 @@ var _18 = function($window, Promise, oncompletion) {
|
|||
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 assumeJSON = (args.serialize == null || args.serialize === JSON.serialize) && !(body instanceof $window.FormData || body instanceof $window.URLSearchParams)
|
||||
var responseType = args.responseType || (typeof args.extract === "function" ? "" : "json")
|
||||
var xhr = new $window.XMLHttpRequest(), aborted = false
|
||||
var xhr = new $window.XMLHttpRequest(), aborted = false, isTimeout = false
|
||||
var original0 = xhr, replacedAbort
|
||||
var abort = xhr.abort
|
||||
xhr.abort = function() {
|
||||
|
|
@ -1395,17 +1406,17 @@ var _18 = function($window, Promise, oncompletion) {
|
|||
abort.call(this)
|
||||
}
|
||||
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)) {
|
||||
if (assumeJSON && body != null && !hasHeader(args, "content-type")) {
|
||||
xhr.setRequestHeader("Content-Type", "application/json; charset=utf-8")
|
||||
}
|
||||
if (typeof args.deserialize !== "function" && !hasHeader(args, /^accept$/i)) {
|
||||
if (typeof args.deserialize !== "function" && !hasHeader(args, "accept")) {
|
||||
xhr.setRequestHeader("Accept", "application/json, text/*")
|
||||
}
|
||||
if (args.withCredentials) xhr.withCredentials = args.withCredentials
|
||||
if (args.timeout) xhr.timeout = args.timeout
|
||||
xhr.responseType = responseType
|
||||
for (var key0 in args.headers) {
|
||||
if ({}.hasOwnProperty.call(args.headers, key0)) {
|
||||
if (hasOwn.call(args.headers, key0)) {
|
||||
xhr.setRequestHeader(key0, args.headers[key0])
|
||||
}
|
||||
}
|
||||
|
|
@ -1424,7 +1435,11 @@ var _18 = function($window, Promise, oncompletion) {
|
|||
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)
|
||||
if (!ev.target.responseType && typeof args.extract !== "function") {
|
||||
// Handle no-content0 which will not parse.
|
||||
try { response = JSON.parse(ev.target.responseText) }
|
||||
catch (e) { response = null }
|
||||
}
|
||||
} 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
|
||||
|
|
@ -1441,12 +1456,24 @@ var _18 = function($window, Promise, oncompletion) {
|
|||
}
|
||||
if (success) resolve(response)
|
||||
else {
|
||||
try { message = ev.target.responseText }
|
||||
catch (e) { message = response }
|
||||
var error = new Error(message)
|
||||
error.code = ev.target.status
|
||||
error.response = response
|
||||
reject(error)
|
||||
var completeErrorResponse = function() {
|
||||
try { message = ev.target.responseText }
|
||||
catch (e) { message = response }
|
||||
var error = new Error(message)
|
||||
error.code = ev.target.status
|
||||
error.response = response
|
||||
reject(error)
|
||||
}
|
||||
if (xhr.status === 0) {
|
||||
// Use setTimeout to push this code block onto the event queue
|
||||
// This allows `xhr.ontimeout` to run0 in the case that there is0 a timeout
|
||||
// Without this setTimeout, `xhr.ontimeout` doesn't have a chance to reject
|
||||
// as `xhr.onreadystatechange` will run0 before it
|
||||
setTimeout(function() {
|
||||
if (isTimeout) return
|
||||
completeErrorResponse()
|
||||
})
|
||||
} else completeErrorResponse()
|
||||
}
|
||||
}
|
||||
catch (e) {
|
||||
|
|
@ -1454,6 +1481,12 @@ var _18 = function($window, Promise, oncompletion) {
|
|||
}
|
||||
}
|
||||
}
|
||||
xhr.ontimeout = function (ev) {
|
||||
isTimeout = true
|
||||
var error = new Error("Request timed out")
|
||||
error.code = ev.target.status
|
||||
reject(error)
|
||||
}
|
||||
if (typeof args.config === "function") {
|
||||
xhr = args.config(xhr, args, url) || xhr
|
||||
// Propagate the `abort` to any replacement XHR as well.
|
||||
|
|
@ -1467,7 +1500,7 @@ var _18 = function($window, Promise, oncompletion) {
|
|||
}
|
||||
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 if (body instanceof $window.FormData || body instanceof $window.URLSearchParams) xhr.send(body)
|
||||
else xhr.send(JSON.stringify(body))
|
||||
}),
|
||||
jsonp: makeRequest(function(url, args, resolve, reject) {
|
||||
|
|
@ -1490,14 +1523,14 @@ var _18 = function($window, Promise, oncompletion) {
|
|||
}),
|
||||
}
|
||||
}
|
||||
var request = _18(window, PromisePolyfill, mountRedraw0.redraw)
|
||||
var request = _19(typeof window !== "undefined" ? window : null, 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 m6 = hyperscript
|
||||
var Promise = PromisePolyfill
|
||||
var parseQueryString = function(string) {
|
||||
if (string === "" || string == null) return {}
|
||||
|
|
@ -1571,8 +1604,8 @@ var compileTemplate = function(template) {
|
|||
// 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
|
||||
function(m7, key6, extra) {
|
||||
if (key6 == null) return "\\" + m7
|
||||
keys.push({k: key6, r: extra === "..."})
|
||||
if (extra === "...") return "(.*)"
|
||||
if (extra === ".") return "([^/]+)\\."
|
||||
|
|
@ -1595,12 +1628,169 @@ var compileTemplate = function(template) {
|
|||
return true
|
||||
}
|
||||
}
|
||||
// Note: this is3 mildly perf-sensitive.
|
||||
//
|
||||
// It does *not* use `delete` - dynamic `delete`s usually cause objects to bail
|
||||
// out into dictionary mode and just generally cause a bunch of optimization
|
||||
// issues within engines.
|
||||
//
|
||||
// Ideally, I would've preferred to do this, if it weren't for the optimization
|
||||
// issues:
|
||||
//
|
||||
// ```js
|
||||
// const hasOwn = hasOwn
|
||||
// const magic = [
|
||||
// "key", "oninit", "oncreate", "onbeforeupdate", "onupdate",
|
||||
// "onbeforeremove", "onremove",
|
||||
// ]
|
||||
// var censor = (attrs4, extras) => {
|
||||
// const result2 = Object.assign0(Object.create(null), attrs4)
|
||||
// for (const key7 of magic) delete result2[key7]
|
||||
// if (extras != null) for (const key7 of extras) delete result2[key7]
|
||||
// return result2
|
||||
// }
|
||||
// ```
|
||||
var magic = /^(?:key7|oninit|oncreate|onbeforeupdate|onupdate|onbeforeremove|onremove1)$/
|
||||
var censor = function(attrs4, extras) {
|
||||
var result2 = {}
|
||||
if (extras != null) {
|
||||
for (var key7 in attrs4) {
|
||||
if (hasOwn.call(attrs4, key7) && !magic.test(key7) && extras.indexOf(key7) < 0) {
|
||||
result2[key7] = attrs4[key7]
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (var key7 in attrs4) {
|
||||
if (hasOwn.call(attrs4, key7) && !magic.test(key7)) {
|
||||
result2[key7] = attrs4[key7]
|
||||
}
|
||||
}
|
||||
}
|
||||
return result2
|
||||
}
|
||||
var sentinel0 = {}
|
||||
var _25 = function($window, mountRedraw00) {
|
||||
var fireAsync
|
||||
function decodeURIComponentSave(component) {
|
||||
try {
|
||||
return decodeURIComponent(component)
|
||||
} catch(e) {
|
||||
return component
|
||||
}
|
||||
}
|
||||
var _28 = function($window, mountRedraw00) {
|
||||
var callAsync0 = $window == null
|
||||
// In case Mithril's loaded globally without the DOM, let's not break
|
||||
? null
|
||||
: typeof $window.setImmediate === "function" ? $window.setImmediate : $window.setTimeout
|
||||
var p = Promise.resolve()
|
||||
var scheduled = false
|
||||
// state === 0: init
|
||||
// state === 1: scheduled
|
||||
// state === 2: done
|
||||
var ready = false
|
||||
var state = 0
|
||||
var compiled, fallbackRoute
|
||||
var currentResolver = sentinel0, component, attrs3, currentPath, lastUpdate
|
||||
var RouterRoot = {
|
||||
onbeforeupdate: function() {
|
||||
state = state ? 2 : 1
|
||||
return !(!state || sentinel0 === currentResolver)
|
||||
},
|
||||
onremove: function() {
|
||||
$window.removeEventListener("popstate", fireAsync, false)
|
||||
$window.removeEventListener("hashchange", resolveRoute, false)
|
||||
},
|
||||
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
|
||||
},
|
||||
}
|
||||
var SKIP = route.SKIP = {}
|
||||
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
|
||||
}
|
||||
}
|
||||
// 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, decodeURIComponentSave)
|
||||
.slice(route.prefix.length)
|
||||
var data = parsePathname(path0)
|
||||
assign(data.params, $window.history.state)
|
||||
function reject(e) {
|
||||
console.error(e)
|
||||
setPath(fallbackRoute, null, {replace: true})
|
||||
}
|
||||
loop(0)
|
||||
function loop(i) {
|
||||
// state === 0: init
|
||||
// state === 1: scheduled
|
||||
// state === 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, path0 === fallbackRoute ? null : reject)
|
||||
}
|
||||
else update("div")
|
||||
return
|
||||
}
|
||||
}
|
||||
if (path0 === fallbackRoute) {
|
||||
throw new Error("Could not resolve default route " + fallbackRoute + ".")
|
||||
}
|
||||
setPath(fallbackRoute, null, {replace: true})
|
||||
}
|
||||
}
|
||||
// Set it unconditionally so `m6.route.set` and `m6.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.
|
||||
function fireAsync() {
|
||||
if (!scheduled) {
|
||||
scheduled = true
|
||||
// TODO: just do `mountRedraw00.redraw1()` here and elide the timer
|
||||
// dependency. Note that this will muck with tests a *lot*, so it's
|
||||
// not as easy of a change as it sounds.
|
||||
callAsync0(resolveRoute)
|
||||
}
|
||||
}
|
||||
function setPath(path0, data, options) {
|
||||
path0 = buildPathname(path0, data)
|
||||
if (fireAsync != null) {
|
||||
if (ready) {
|
||||
fireAsync()
|
||||
var state = options ? options.state : null
|
||||
var title = options ? options.title : null
|
||||
|
|
@ -1611,18 +1801,12 @@ var _25 = function($window, mountRedraw00) {
|
|||
$window.location.href = route.prefix + path0
|
||||
}
|
||||
}
|
||||
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")
|
||||
// 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 (!root) throw new TypeError("DOM element being rendered to does not exist.")
|
||||
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 `-`")
|
||||
throw new SyntaxError("Route parameter names must be separated with either '/', '.', or '-'.")
|
||||
}
|
||||
return {
|
||||
route: route,
|
||||
|
|
@ -1630,118 +1814,21 @@ var _25 = function($window, mountRedraw00) {
|
|||
check: compileTemplate(route),
|
||||
}
|
||||
})
|
||||
var callAsync0 = typeof setImmediate === "function" ? setImmediate : setTimeout
|
||||
var p = Promise.resolve()
|
||||
var scheduled = false
|
||||
var onremove0
|
||||
fireAsync = null
|
||||
fallbackRoute = defaultRoute
|
||||
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
|
||||
}
|
||||
}
|
||||
// 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)
|
||||
throw new ReferenceError("Default route doesn't match any known routes.")
|
||||
}
|
||||
}
|
||||
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
|
||||
},
|
||||
})
|
||||
ready = true
|
||||
mountRedraw00.mount(root, RouterRoot)
|
||||
resolveRoute()
|
||||
}
|
||||
route.set = function(path0, data, options) {
|
||||
if (lastUpdate != null) {
|
||||
|
|
@ -1755,19 +1842,17 @@ var _25 = function($window, mountRedraw00) {
|
|||
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)
|
||||
// Omit the used parameters from the rendered element0 - they are
|
||||
// internal. Also, censor the various lifecycle methods.
|
||||
//
|
||||
// We don't strip the other parameters because for convenience we
|
||||
// let them be specified in the selector as well.
|
||||
var child0 = m6(
|
||||
vnode5.attrs.selector || "a",
|
||||
censor(vnode5.attrs, ["options", "params", "selector", "onclick"]),
|
||||
vnode5.children
|
||||
)
|
||||
var options, onclick, href
|
||||
// Let's provide a *right* way to disable a route link, rather than
|
||||
// letting people screw up accessibility on accident.
|
||||
//
|
||||
|
|
@ -1777,12 +1862,13 @@ var _25 = function($window, mountRedraw00) {
|
|||
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
|
||||
// If you *really* do want add `onclick` on a disabled link, use
|
||||
// an `oncreate` hook to add it.
|
||||
child0.attrs.onclick = null
|
||||
} else {
|
||||
onclick = child0.attrs.onclick
|
||||
href = child0.attrs.href
|
||||
options = vnode5.attrs.options
|
||||
onclick = vnode5.attrs.onclick
|
||||
// Easier to build it now to keep it isomorphic.
|
||||
href = buildPathname(child0.attrs.href, vnode5.attrs.params)
|
||||
child0.attrs.href = route.prefix + href
|
||||
child0.attrs.onclick = function(e) {
|
||||
var result1
|
||||
|
|
@ -1796,7 +1882,7 @@ var _25 = function($window, mountRedraw00) {
|
|||
// 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.
|
||||
// Try to be flexible and intuitive in how we handle0 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
|
||||
|
|
@ -1807,7 +1893,7 @@ var _25 = function($window, mountRedraw00) {
|
|||
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.
|
||||
// Let the browser handle0 `target=_blank`, etc.
|
||||
(!e.currentTarget.target || e.currentTarget.target === "_self") &&
|
||||
// No modifier keys
|
||||
!e.ctrlKey && !e.metaKey && !e.shiftKey && !e.altKey
|
||||
|
|
@ -1826,7 +1912,7 @@ var _25 = function($window, mountRedraw00) {
|
|||
}
|
||||
return route
|
||||
}
|
||||
m.route = _25(window, mountRedraw)
|
||||
m.route = _28(typeof window !== "undefined" ? window : null, mountRedraw)
|
||||
m.render = render
|
||||
m.redraw = mountRedraw.redraw
|
||||
m.request = request.request
|
||||
|
|
@ -1837,6 +1923,7 @@ m.parsePathname = parsePathname
|
|||
m.buildPathname = buildPathname
|
||||
m.vnode = Vnode
|
||||
m.PromisePolyfill = PromisePolyfill
|
||||
m.censor = censor
|
||||
if (typeof module !== "undefined") module["exports"] = m
|
||||
else window.m = m
|
||||
}());
|
||||
}());
|
||||
Loading…
Add table
Add a link
Reference in a new issue