@reactive-vscode/reactivity 0.2.0-beta.1 → 0.2.0-beta.2

package/src/scheduler.ts

@@ -1,211 +0,0 @@
-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)
-    }
-  }
-}

package/src/warning.ts

@@ -1,13 +0,0 @@
-import { pauseTracking, resetTracking } from '@vue/reactivity'
-
-export function warn(msg: string, ...args: any[]) {
-  // avoid props formatting or warn handler tracking deps that might be mutated
-  // during patch, leading to infinite recursion.
-  pauseTracking()
-
-  const warnArgs = [`[Vue warn]: ${msg}`, ...args]
-  /* istanbul ignore if */
-  console.warn(...warnArgs)
-
-  resetTracking()
-}

package/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json"
-}