@mpxjs/core 2.9.10 → 2.9.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpxjs/core",
-  "version": "2.9.10",
+  "version": "2.9.11",
   "description": "mpx runtime core",
   "keywords": [
     "miniprogram",
@@ -47,5 +47,5 @@
     "url": "https://github.com/didi/mpx/issues"
   },
   "sideEffects": false,
-  "gitHead": "d2e853a8246e8f9c37f8439c9e276bde22c3ba38"
+  "gitHead": "5077a6d6d3960fe63118d8151dcee91be797ebfe"
 }

package/src/core/proxy.js

@@ -531,7 +531,7 @@ export default class MpxProxy {
   updatePreRender () {
     this.toggleRecurse(false)
     pauseTracking()
-    flushPreFlushCbs(undefined, this.update)
+    flushPreFlushCbs(this)
     resetTracking()
     this.toggleRecurse(true)
   }

package/src/observer/scheduler.js

@@ -7,22 +7,26 @@ let isFlushPending = false
 const queue = []
 let flushIndex = 0
 
-const pendingPreFlushCbs = []
-let activePreFlushCbs = null
-let preFlushIndex = 0
-
 const pendingPostFlushCbs = []
 let activePostFlushCbs = null
 let postFlushIndex = 0
 
 const resolvedPromise = Promise.resolve()
 let currentFlushPromise = null
-let currentPreFlushParentJob = null
 
 const RECURSION_LIMIT = 100
 
 const getId = (job) => job.id == null ? Infinity : job.id
 
+const comparator = (a, b) => {
+  const diff = getId(a) - getId(b)
+  if (diff === 0) {
+    if (a.pre && !b.pre) return -1
+    if (b.pre && !a.pre) return 1
+  }
+  return diff
+}
+
 function findInsertionIndex (id) {
   // the start index should be `flushIndex + 1`
   let start = flushIndex + 1
@@ -30,8 +34,13 @@ function findInsertionIndex (id) {
 
   while (start < end) {
     const middle = (start + end) >>> 1
-    const middleJobId = getId(queue[middle])
-    middleJobId < id ? (start = middle + 1) : (end = middle)
+    const middleJob = queue[middle]
+    const middleJobId = getId(middleJob)
+    if (middleJobId < id || (middleJobId === id && middleJob.pre)) {
+      start = middle + 1
+    } else {
+      end = middle
+    }
   }
 
   return start
@@ -42,22 +51,14 @@ export function nextTick (fn) {
   return fn ? p.then(this ? fn.bind(this) : fn) : p
 }
 
-export function queuePreFlushCb (cb) {
-  queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex)
-}
-
 export function queuePostFlushCb (cb) {
-  queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex)
-}
-
-function queueCb (cb, activeQueue, pendingQueue, index) {
   if (isArray(cb)) {
-    pendingQueue.push(...cb)
+    pendingPostFlushCbs.push(...cb)
   } else if (
-    !activeQueue ||
-    !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)
+    !activePostFlushCbs ||
+    !activePostFlushCbs.includes(cb, cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex)
   ) {
-    pendingQueue.push(cb)
+    pendingPostFlushCbs.push(cb)
   }
   queueFlush()
 }
@@ -69,11 +70,10 @@ export function queueJob (job) {
   // if the job is a watch() callback, the search will start with a +1 index to
   // allow it recursively trigger itself - it is the user's responsibility to
   // ensure it doesn't end up in an infinite loop.
-  if ((
-      !queue.length ||
-      !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)
-    ) &&
-    job !== currentPreFlushParentJob) {
+  if (
+    !queue.length ||
+    !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)
+  ) {
     if (job.id == null) {
       queue.push(job)
     } else {
@@ -94,31 +94,17 @@ function queueFlush () {
   }
 }
 
-// todo follow vue
-export function flushPreFlushCbs (seen, parentJob = null) {
-  if (pendingPreFlushCbs.length) {
-    const deduped = [...new Set(pendingPreFlushCbs)]
-    pendingPreFlushCbs.length = 0
-    if (activePreFlushCbs) {
-      activePreFlushCbs.push(...deduped)
-      return
-    }
-    currentPreFlushParentJob = parentJob
-    activePreFlushCbs = deduped
-    if (isDev) seen = seen || new Map()
-    for (
-      preFlushIndex = 0;
-      preFlushIndex < activePreFlushCbs.length;
-      preFlushIndex++
-    ) {
-      if (isDev && checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex])) continue
-      activePreFlushCbs[preFlushIndex]()
+export function flushPreFlushCbs (instance, seen) {
+  if (isDev) seen = seen || new Map()
+  for (let i = isFlushing ? flushIndex + 1 : 0; i < queue.length; i++) {
+    const cb = queue[i]
+    if (cb && cb.pre) {
+      if (instance && cb.id !== instance.uid) continue
+      if (isDev && checkRecursiveUpdates(seen, cb)) continue
+      queue.splice(i, 1)
+      i--
+      cb()
     }
-    activePreFlushCbs = null
-    preFlushIndex = 0
-    currentPreFlushParentJob = null
-    // recursively flush until it drains
-    flushPreFlushCbs(seen, parentJob)
   }
 }
 
@@ -143,8 +129,6 @@ export function flushPostFlushCbs (seen) {
     }
     activePostFlushCbs = null
     postFlushIndex = 0
-    // recursively flush until it drains
-    flushPostFlushCbs(seen)
   }
 }
 
@@ -154,16 +138,14 @@ function flushJobs (seen) {
 
   if (isDev) seen = seen || new Map()
 
-  flushPreFlushCbs(seen)
-
-  queue.sort((a, b) => getId(a) - getId(b))
+  queue.sort(comparator)
 
   try {
     for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
       const job = queue[flushIndex]
       if (job && job.active !== false) {
         if (isDev && checkRecursiveUpdates(seen, job)) continue
-        callWithErrorHandling(job, null, 'render job')
+        callWithErrorHandling(job, null, 'scheduler')
       }
     }
   } finally {
@@ -176,11 +158,7 @@ function flushJobs (seen) {
     currentFlushPromise = null
     // some postFlushCb queued jobs!
     // keep flushing until it drains.
-    if (
-      queue.length ||
-      pendingPreFlushCbs.length ||
-      pendingPostFlushCbs.length
-    ) {
+    if (queue.length || pendingPostFlushCbs.length) {
       flushJobs(seen)
     }
   }

package/src/observer/watch.js

@@ -1,7 +1,7 @@
 import { ReactiveEffect } from './effect'
 import { isRef } from './ref'
 import { isReactive } from './reactive'
-import { queuePreFlushCb, queuePostFlushCb } from './scheduler'
+import { queueJob, queuePostFlushCb } from './scheduler'
 import { currentInstance } from '../core/proxy'
 import {
   noop,
@@ -129,7 +129,9 @@ export function watch (source, cb, options = {}) {
     scheduler = () => queuePostFlushCb(job)
   } else {
     // default: 'pre'
-    scheduler = () => queuePreFlushCb(job)
+    job.pre = true
+    if (instance) job.id = instance.uid
+    scheduler = () => queueJob(job)
   }
 
   job.allowRecurse = !!cb