From 55f31f04733f73d6144b1101bab4c6b4eda7ae4b Mon Sep 17 00:00:00 2001 From: windy <1374721899@qq.com> Date: Fri, 21 Feb 2020 14:19:13 +0800 Subject: [PATCH] =?UTF-8?q?=E6=97=A0JIRA=E4=BB=BB=E5=8A=A1=20=E6=9B=B4?= =?UTF-8?q?=E6=96=B0fix.ie?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- dist/fix/fix.ie.js | 66 +++++++++++++++++----------------------------- 1 file changed, 24 insertions(+), 42 deletions(-) diff --git a/dist/fix/fix.ie.js b/dist/fix/fix.ie.js index 058c1e930..3c8b595d3 100644 --- a/dist/fix/fix.ie.js +++ b/dist/fix/fix.ie.js @@ -166,55 +166,37 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons } } - // Here we have async deferring wrappers using microtasks. - // In 2.5 we used (macro) tasks (in combination with microtasks). - // However, it has subtle problems when state is changed right before repaint - // (e.g. #6813, out-in transitions). - // Also, using (macro) tasks in event handler would cause some weird behaviors - // that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109). - // So we now use microtasks everywhere, again. - // A major drawback of this tradeoff is that there are some scenarios - // where microtasks have too high a priority and fire in between supposedly - // sequential events (e.g. #4521, #6690, which have workarounds) - // or even between bubbling of the same event (#6566). - - // The nextTick behavior leverages the microtask queue, which can be accessed - // via either native Promise.then or MutationObserver. - // MutationObserver has wider support, however it is seriously bugged in - // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It - // completely stops working after triggering a few times... so, if native - // Promise is available, we will use it: - /* istanbul ignore next, $flow-disable-line */ - if (typeof Promise !== 'undefined' && isNative(Promise)) { - var p = Promise.resolve(); + // An asynchronous deferring mechanism. + // In pre 2.4, we used to use microtasks (Promise/MutationObserver) + // but microtasks actually has too high a priority and fires in between + // supposedly sequential events (e.g. #4521, #6690) or even between + // bubbling of the same event (#6566). Technically setImmediate should be + // the ideal choice, but it's not available everywhere; and the only polyfill + // that consistently queues the callback after all DOM events triggered in the + // same loop is by using MessageChannel. + /* istanbul ignore if */ + if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) { timerFunc = function timerFunc() { - p.then(nextTickHandler); + setImmediate(nextTickHandler); }; - } else if (!isIE && typeof MutationObserver !== 'undefined' && (isNative(MutationObserver) || - // PhantomJS and iOS 7.x - MutationObserver.toString() === '[object MutationObserverConstructor]')) { - // Use MutationObserver where native Promise is not available, - // e.g. PhantomJS, iOS7, Android 4.4 - // (#6466 MutationObserver is unreliable in IE11) - var counter = 1; - var observer = new MutationObserver(nextTickHandler); - var textNode = document.createTextNode(String(counter)); - observer.observe(textNode, { - characterData: true - }); + } else if (typeof MessageChannel !== 'undefined' && (isNative(MessageChannel) || + // PhantomJS + MessageChannel.toString() === '[object MessageChannelConstructor]')) { + var channel = new MessageChannel(); + var port = channel.port2; + channel.port1.onmessage = nextTickHandler; timerFunc = function timerFunc() { - counter = (counter + 1) % 2; - textNode.data = String(counter); + port.postMessage(1); }; - } else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) { - // Fallback to setImmediate. - // Technically it leverages the (macro) task queue, - // but it is still a better choice than setTimeout. + /* istanbul ignore next */ + } else if (typeof Promise !== 'undefined' && isNative(Promise)) { + // use microtask in non-DOM environments, e.g. Weex + var p = Promise.resolve(); timerFunc = function timerFunc() { - setImmediate(nextTickHandler); + p.then(nextTickHandler); }; } else { - // Fallback to setTimeout. + // fallback to setTimeout timerFunc = function timerFunc() { setTimeout(nextTickHandler, 0); };