@reactive-vscode/reactivity 0.0.1-beta.5 → 0.0.1-beta.6

package/src/errorHandling.ts

@@ -1,120 +1,120 @@
-import { warn } from './warning'
-import { isArray, isFunction, isPromise } from '@vue/shared'
-import { LifecycleHooks } from './enums'
-
-// contexts where user provided function may be executed, in addition to
-// lifecycle hooks.
-export enum ErrorCodes {
-  SETUP_FUNCTION,
-  RENDER_FUNCTION,
-  WATCH_GETTER,
-  WATCH_CALLBACK,
-  WATCH_CLEANUP,
-  NATIVE_EVENT_HANDLER,
-  COMPONENT_EVENT_HANDLER,
-  VNODE_HOOK,
-  DIRECTIVE_HOOK,
-  TRANSITION_HOOK,
-  APP_ERROR_HANDLER,
-  APP_WARN_HANDLER,
-  FUNCTION_REF,
-  ASYNC_COMPONENT_LOADER,
-  SCHEDULER,
-}
-
-export const ErrorTypeStrings: Record<LifecycleHooks | ErrorCodes, string> = {
-  [LifecycleHooks.ACTIVATED]: 'activated hook',
-  [LifecycleHooks.DEACTIVATED]: 'deactivated hook',
-  [ErrorCodes.SETUP_FUNCTION]: 'setup function',
-  [ErrorCodes.RENDER_FUNCTION]: 'render function',
-  [ErrorCodes.WATCH_GETTER]: 'watcher getter',
-  [ErrorCodes.WATCH_CALLBACK]: 'watcher callback',
-  [ErrorCodes.WATCH_CLEANUP]: 'watcher cleanup function',
-  [ErrorCodes.NATIVE_EVENT_HANDLER]: 'native event handler',
-  [ErrorCodes.COMPONENT_EVENT_HANDLER]: 'component event handler',
-  [ErrorCodes.VNODE_HOOK]: 'vnode hook',
-  [ErrorCodes.DIRECTIVE_HOOK]: 'directive hook',
-  [ErrorCodes.TRANSITION_HOOK]: 'transition hook',
-  [ErrorCodes.APP_ERROR_HANDLER]: 'app errorHandler',
-  [ErrorCodes.APP_WARN_HANDLER]: 'app warnHandler',
-  [ErrorCodes.FUNCTION_REF]: 'ref function',
-  [ErrorCodes.ASYNC_COMPONENT_LOADER]: 'async component loader',
-  [ErrorCodes.SCHEDULER]:
-    'scheduler flush. This is likely a Vue internals bug. ' +
-    'Please open an issue at https://github.com/vuejs/core .',
-}
-
-export type ErrorTypes = LifecycleHooks | ErrorCodes
-
-export function callWithErrorHandling(
-  fn: Function,
-  instance: null,
-  type: ErrorTypes,
-  args?: unknown[],
-) {
-  try {
-    return args ? fn(...args) : fn()
-  } catch (err) {
-    handleError(err, instance, type)
-  }
-}
-
-export function callWithAsyncErrorHandling(
-  fn: Function | Function[],
-  instance: null,
-  type: ErrorTypes,
-  args?: unknown[],
-): any {
-  if (isFunction(fn)) {
-    const res = callWithErrorHandling(fn, instance, type, args)
-    if (res && isPromise(res)) {
-      res.catch(err => {
-        handleError(err, instance, type)
-      })
-    }
-    return res
-  }
-
-  if (isArray(fn)) {
-    const values = []
-    for (let i = 0; i < fn.length; i++) {
-      values.push(callWithAsyncErrorHandling(fn[i], instance, type, args))
-    }
-    return values
-  } else if (__DEV__) {
-    warn(
-      `Invalid value type passed to callWithAsyncErrorHandling(): ${typeof fn}`,
-    )
-  }
-}
-
-export function handleError(
-  err: unknown,
-  instance: null,
-  type: ErrorTypes,
-  throwInDev = true,
-) {
-  const contextVNode = null
-  logError(err, type, contextVNode, throwInDev)
-}
-
-function logError(
-  err: unknown,
-  type: ErrorTypes,
-  contextVNode: null,
-  throwInDev = true,
-) {
-  if (__DEV__) {
-    const info = ErrorTypeStrings[type]
-    warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`)
-    // crash in dev by default so it's more noticeable
-    if (throwInDev) {
-      throw err
-    } else {
-      console.error(err)
-    }
-  } else {
-    // recover in prod to reduce the impact on end-user
-    console.error(err)
-  }
+import { warn } from './warning'
+import { isArray, isFunction, isPromise } from '@vue/shared'
+import { LifecycleHooks } from './enums'
+
+// contexts where user provided function may be executed, in addition to
+// lifecycle hooks.
+export enum ErrorCodes {
+  SETUP_FUNCTION,
+  RENDER_FUNCTION,
+  WATCH_GETTER,
+  WATCH_CALLBACK,
+  WATCH_CLEANUP,
+  NATIVE_EVENT_HANDLER,
+  COMPONENT_EVENT_HANDLER,
+  VNODE_HOOK,
+  DIRECTIVE_HOOK,
+  TRANSITION_HOOK,
+  APP_ERROR_HANDLER,
+  APP_WARN_HANDLER,
+  FUNCTION_REF,
+  ASYNC_COMPONENT_LOADER,
+  SCHEDULER,
+}
+
+export const ErrorTypeStrings: Record<LifecycleHooks | ErrorCodes, string> = {
+  [LifecycleHooks.ACTIVATED]: 'activated hook',
+  [LifecycleHooks.DEACTIVATED]: 'deactivated hook',
+  [ErrorCodes.SETUP_FUNCTION]: 'setup function',
+  [ErrorCodes.RENDER_FUNCTION]: 'render function',
+  [ErrorCodes.WATCH_GETTER]: 'watcher getter',
+  [ErrorCodes.WATCH_CALLBACK]: 'watcher callback',
+  [ErrorCodes.WATCH_CLEANUP]: 'watcher cleanup function',
+  [ErrorCodes.NATIVE_EVENT_HANDLER]: 'native event handler',
+  [ErrorCodes.COMPONENT_EVENT_HANDLER]: 'component event handler',
+  [ErrorCodes.VNODE_HOOK]: 'vnode hook',
+  [ErrorCodes.DIRECTIVE_HOOK]: 'directive hook',
+  [ErrorCodes.TRANSITION_HOOK]: 'transition hook',
+  [ErrorCodes.APP_ERROR_HANDLER]: 'app errorHandler',
+  [ErrorCodes.APP_WARN_HANDLER]: 'app warnHandler',
+  [ErrorCodes.FUNCTION_REF]: 'ref function',
+  [ErrorCodes.ASYNC_COMPONENT_LOADER]: 'async component loader',
+  [ErrorCodes.SCHEDULER]:
+    'scheduler flush. This is likely a Vue internals bug. ' +
+    'Please open an issue at https://github.com/vuejs/core .',
+}
+
+export type ErrorTypes = LifecycleHooks | ErrorCodes
+
+export function callWithErrorHandling(
+  fn: Function,
+  instance: null,
+  type: ErrorTypes,
+  args?: unknown[],
+) {
+  try {
+    return args ? fn(...args) : fn()
+  } catch (err) {
+    handleError(err, instance, type)
+  }
+}
+
+export function callWithAsyncErrorHandling(
+  fn: Function | Function[],
+  instance: null,
+  type: ErrorTypes,
+  args?: unknown[],
+): any {
+  if (isFunction(fn)) {
+    const res = callWithErrorHandling(fn, instance, type, args)
+    if (res && isPromise(res)) {
+      res.catch(err => {
+        handleError(err, instance, type)
+      })
+    }
+    return res
+  }
+
+  if (isArray(fn)) {
+    const values = []
+    for (let i = 0; i < fn.length; i++) {
+      values.push(callWithAsyncErrorHandling(fn[i], instance, type, args))
+    }
+    return values
+  } else if (__DEV__) {
+    warn(
+      `Invalid value type passed to callWithAsyncErrorHandling(): ${typeof fn}`,
+    )
+  }
+}
+
+export function handleError(
+  err: unknown,
+  instance: null,
+  type: ErrorTypes,
+  throwInDev = true,
+) {
+  const contextVNode = null
+  logError(err, type, contextVNode, throwInDev)
+}
+
+function logError(
+  err: unknown,
+  type: ErrorTypes,
+  contextVNode: null,
+  throwInDev = true,
+) {
+  if (__DEV__) {
+    const info = ErrorTypeStrings[type]
+    warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`)
+    // crash in dev by default so it's more noticeable
+    if (throwInDev) {
+      throw err
+    } else {
+      console.error(err)
+    }
+  } else {
+    // recover in prod to reduce the impact on end-user
+    console.error(err)
+  }
 }

package/src/scheduler.ts

@@ -1,211 +1,211 @@
-import { ErrorCodes, callWithErrorHandling, handleError } from './errorHandling'
-import { type Awaited, NOOP, isArray } from '@vue/shared'
-
-export interface SchedulerJob extends Function {
-  id?: number
-  pre?: boolean
-  active?: boolean
-  computed?: boolean
-  /**
-   * Indicates whether the effect is allowed to recursively trigger itself
-   * when managed by the scheduler.
-   *
-   * By default, a job cannot trigger itself because some built-in method calls,
-   * e.g. Array.prototype.push actually performs reads as well (#1740) which
-   * can lead to confusing infinite loops.
-   * The allowed cases are component update functions and watch callbacks.
-   * Component update functions may update child component props, which in turn
-   * trigger flush: "pre" watch callbacks that mutates state that the parent
-   * relies on (#1801). Watch callbacks doesn't track its dependencies so if it
-   * triggers itself again, it's likely intentional and it is the user's
-   * responsibility to perform recursive state mutation that eventually
-   * stabilizes (#1727).
-   */
-  allowRecurse?: boolean
-}
-
-export type SchedulerJobs = SchedulerJob | SchedulerJob[]
-
-let isFlushing = false
-let isFlushPending = false
-
-const queue: SchedulerJob[] = []
-let flushIndex = 0
-
-const resolvedPromise = /*#__PURE__*/ Promise.resolve() as Promise<any>
-let currentFlushPromise: Promise<void> | null = null
-
-const RECURSION_LIMIT = 100
-type CountMap = Map<SchedulerJob, number>
-
-export function nextTick<T = void, R = void>(
-  this: T,
-  fn?: (this: T) => R,
-): Promise<Awaited<R>> {
-  const p = currentFlushPromise || resolvedPromise
-  return fn ? p.then(this ? fn.bind(this) : fn) : p
-}
-
-// #2768
-// Use binary-search to find a suitable position in the queue,
-// so that the queue maintains the increasing order of job's id,
-// which can prevent the job from being skipped and also can avoid repeated patching.
-function findInsertionIndex(id: number) {
-  // the start index should be `flushIndex + 1`
-  let start = flushIndex + 1
-  let end = queue.length
-
-  while (start < end) {
-    const middle = (start + end) >>> 1
-    const middleJob = queue[middle]
-    const middleJobId = getId(middleJob)
-    if (middleJobId < id || (middleJobId === id && middleJob.pre)) {
-      start = middle + 1
-    } else {
-      end = middle
-    }
-  }
-
-  return start
-}
-
-export function queueJob(job: SchedulerJob) {
-  // the dedupe search uses the startIndex argument of Array.includes()
-  // by default the search index includes the current job that is being run
-  // so it cannot recursively trigger itself again.
-  // 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,
-    )
-  ) {
-    if (job.id == null) {
-      queue.push(job)
-    } else {
-      queue.splice(findInsertionIndex(job.id), 0, job)
-    }
-    queueFlush()
-  }
-}
-
-function queueFlush() {
-  if (!isFlushing && !isFlushPending) {
-    isFlushPending = true
-    currentFlushPromise = resolvedPromise.then(flushJobs)
-  }
-}
-
-export function invalidateJob(job: SchedulerJob) {
-  const i = queue.indexOf(job)
-  if (i > flushIndex) {
-    queue.splice(i, 1)
-  }
-}
-
-export function flushPreFlushCbs(
-  seen?: CountMap,
-  // if currently flushing, skip the current job itself
-  i = isFlushing ? flushIndex + 1 : 0,
-) {
-  if (__DEV__) {
-    seen = seen || new Map()
-  }
-  for (; i < queue.length; i++) {
-    const cb = queue[i]
-    if (cb && cb.pre) {
-      if (__DEV__ && checkRecursiveUpdates(seen!, cb)) {
-        continue
-      }
-      queue.splice(i, 1)
-      i--
-      cb()
-    }
-  }
-}
-
-const getId = (job: SchedulerJob): number =>
-  job.id == null ? Infinity : job.id
-
-const comparator = (a: SchedulerJob, b: SchedulerJob): number => {
-  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 flushJobs(seen?: CountMap) {
-  isFlushPending = false
-  isFlushing = true
-  if (__DEV__) {
-    seen = seen || new Map()
-  }
-
-  // Sort queue before flush.
-  // This ensures that:
-  // 1. Components are updated from parent to child. (because parent is always
-  //    created before the child so its render effect will have smaller
-  //    priority number)
-  // 2. If a component is unmounted during a parent component's update,
-  //    its update can be skipped.
-  queue.sort(comparator)
-
-  // conditional usage of checkRecursiveUpdate must be determined out of
-  // try ... catch block since Rollup by default de-optimizes treeshaking
-  // inside try-catch. This can leave all warning code unshaked. Although
-  // they would get eventually shaken by a minifier like terser, some minifiers
-  // would fail to do that (e.g. https://github.com/evanw/esbuild/issues/1610)
-  const check = __DEV__
-    ? (job: SchedulerJob) => checkRecursiveUpdates(seen!, job)
-    : NOOP
-
-  try {
-    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
-      const job = queue[flushIndex]
-      if (job && job.active !== false) {
-        if (__DEV__ && check(job)) {
-          continue
-        }
-        callWithErrorHandling(job, null, ErrorCodes.SCHEDULER)
-      }
-    }
-  } finally {
-    flushIndex = 0
-    queue.length = 0
-
-    isFlushing = false
-    currentFlushPromise = null
-    // some postFlushCb queued jobs!
-    // keep flushing until it drains.
-    if (queue.length) {
-      flushJobs(seen)
-    }
-  }
-}
-
-function checkRecursiveUpdates(seen: CountMap, fn: SchedulerJob) {
-  if (!seen.has(fn)) {
-    seen.set(fn, 1)
-  } else {
-    const count = seen.get(fn)!
-    if (count > RECURSION_LIMIT) {
-      handleError(
-        `Maximum recursive updates exceeded. ` +
-          `This means you have a reactive effect that is mutating its own ` +
-          `dependencies and thus recursively triggering itself. Possible sources ` +
-          `include component template, render function, updated hook or ` +
-          `watcher source function.`,
-        null,
-        ErrorCodes.APP_ERROR_HANDLER,
-      )
-      return true
-    } else {
-      seen.set(fn, count + 1)
-    }
-  }
+import { ErrorCodes, callWithErrorHandling, handleError } from './errorHandling'
+import { type Awaited, NOOP, isArray } from '@vue/shared'
+
+export interface SchedulerJob extends Function {
+  id?: number
+  pre?: boolean
+  active?: boolean
+  computed?: boolean
+  /**
+   * Indicates whether the effect is allowed to recursively trigger itself
+   * when managed by the scheduler.
+   *
+   * By default, a job cannot trigger itself because some built-in method calls,
+   * e.g. Array.prototype.push actually performs reads as well (#1740) which
+   * can lead to confusing infinite loops.
+   * The allowed cases are component update functions and watch callbacks.
+   * Component update functions may update child component props, which in turn
+   * trigger flush: "pre" watch callbacks that mutates state that the parent
+   * relies on (#1801). Watch callbacks doesn't track its dependencies so if it
+   * triggers itself again, it's likely intentional and it is the user's
+   * responsibility to perform recursive state mutation that eventually
+   * stabilizes (#1727).
+   */
+  allowRecurse?: boolean
+}
+
+export type SchedulerJobs = SchedulerJob | SchedulerJob[]
+
+let isFlushing = false
+let isFlushPending = false
+
+const queue: SchedulerJob[] = []
+let flushIndex = 0
+
+const resolvedPromise = /*#__PURE__*/ Promise.resolve() as Promise<any>
+let currentFlushPromise: Promise<void> | null = null
+
+const RECURSION_LIMIT = 100
+type CountMap = Map<SchedulerJob, number>
+
+export function nextTick<T = void, R = void>(
+  this: T,
+  fn?: (this: T) => R,
+): Promise<Awaited<R>> {
+  const p = currentFlushPromise || resolvedPromise
+  return fn ? p.then(this ? fn.bind(this) : fn) : p
+}
+
+// #2768
+// Use binary-search to find a suitable position in the queue,
+// so that the queue maintains the increasing order of job's id,
+// which can prevent the job from being skipped and also can avoid repeated patching.
+function findInsertionIndex(id: number) {
+  // the start index should be `flushIndex + 1`
+  let start = flushIndex + 1
+  let end = queue.length
+
+  while (start < end) {
+    const middle = (start + end) >>> 1
+    const middleJob = queue[middle]
+    const middleJobId = getId(middleJob)
+    if (middleJobId < id || (middleJobId === id && middleJob.pre)) {
+      start = middle + 1
+    } else {
+      end = middle
+    }
+  }
+
+  return start
+}
+
+export function queueJob(job: SchedulerJob) {
+  // the dedupe search uses the startIndex argument of Array.includes()
+  // by default the search index includes the current job that is being run
+  // so it cannot recursively trigger itself again.
+  // 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,
+    )
+  ) {
+    if (job.id == null) {
+      queue.push(job)
+    } else {
+      queue.splice(findInsertionIndex(job.id), 0, job)
+    }
+    queueFlush()
+  }
+}
+
+function queueFlush() {
+  if (!isFlushing && !isFlushPending) {
+    isFlushPending = true
+    currentFlushPromise = resolvedPromise.then(flushJobs)
+  }
+}
+
+export function invalidateJob(job: SchedulerJob) {
+  const i = queue.indexOf(job)
+  if (i > flushIndex) {
+    queue.splice(i, 1)
+  }
+}
+
+export function flushPreFlushCbs(
+  seen?: CountMap,
+  // if currently flushing, skip the current job itself
+  i = isFlushing ? flushIndex + 1 : 0,
+) {
+  if (__DEV__) {
+    seen = seen || new Map()
+  }
+  for (; i < queue.length; i++) {
+    const cb = queue[i]
+    if (cb && cb.pre) {
+      if (__DEV__ && checkRecursiveUpdates(seen!, cb)) {
+        continue
+      }
+      queue.splice(i, 1)
+      i--
+      cb()
+    }
+  }
+}
+
+const getId = (job: SchedulerJob): number =>
+  job.id == null ? Infinity : job.id
+
+const comparator = (a: SchedulerJob, b: SchedulerJob): number => {
+  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 flushJobs(seen?: CountMap) {
+  isFlushPending = false
+  isFlushing = true
+  if (__DEV__) {
+    seen = seen || new Map()
+  }
+
+  // Sort queue before flush.
+  // This ensures that:
+  // 1. Components are updated from parent to child. (because parent is always
+  //    created before the child so its render effect will have smaller
+  //    priority number)
+  // 2. If a component is unmounted during a parent component's update,
+  //    its update can be skipped.
+  queue.sort(comparator)
+
+  // conditional usage of checkRecursiveUpdate must be determined out of
+  // try ... catch block since Rollup by default de-optimizes treeshaking
+  // inside try-catch. This can leave all warning code unshaked. Although
+  // they would get eventually shaken by a minifier like terser, some minifiers
+  // would fail to do that (e.g. https://github.com/evanw/esbuild/issues/1610)
+  const check = __DEV__
+    ? (job: SchedulerJob) => checkRecursiveUpdates(seen!, job)
+    : NOOP
+
+  try {
+    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
+      const job = queue[flushIndex]
+      if (job && job.active !== false) {
+        if (__DEV__ && check(job)) {
+          continue
+        }
+        callWithErrorHandling(job, null, ErrorCodes.SCHEDULER)
+      }
+    }
+  } finally {
+    flushIndex = 0
+    queue.length = 0
+
+    isFlushing = false
+    currentFlushPromise = null
+    // some postFlushCb queued jobs!
+    // keep flushing until it drains.
+    if (queue.length) {
+      flushJobs(seen)
+    }
+  }
+}
+
+function checkRecursiveUpdates(seen: CountMap, fn: SchedulerJob) {
+  if (!seen.has(fn)) {
+    seen.set(fn, 1)
+  } else {
+    const count = seen.get(fn)!
+    if (count > RECURSION_LIMIT) {
+      handleError(
+        `Maximum recursive updates exceeded. ` +
+          `This means you have a reactive effect that is mutating its own ` +
+          `dependencies and thus recursively triggering itself. Possible sources ` +
+          `include component template, render function, updated hook or ` +
+          `watcher source function.`,
+        null,
+        ErrorCodes.APP_ERROR_HANDLER,
+      )
+      return true
+    } else {
+      seen.set(fn, count + 1)
+    }
+  }
 }