@builder.io/sdk-vue 0.6.1-1 → 0.6.1

package/vue2/node_modules/vue/src/core/observer/index.ts

@@ -1,338 +0,0 @@
-import Dep from './dep'
-import VNode from '../vdom/vnode'
-import { arrayMethods } from './array'
-import {
-  def,
-  warn,
-  hasOwn,
-  isArray,
-  hasProto,
-  isPlainObject,
-  isPrimitive,
-  isUndef,
-  isValidArrayIndex,
-  isServerRendering,
-  hasChanged,
-  noop
-} from '../util/index'
-import { isReadonly, isRef, TrackOpTypes, TriggerOpTypes } from '../../v3'
-
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods)
-
-const NO_INIITIAL_VALUE = {}
-
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-export let shouldObserve: boolean = true
-
-export function toggleObserving(value: boolean) {
-  shouldObserve = value
-}
-
-// ssr mock dep
-const mockDep = {
-  notify: noop,
-  depend: noop,
-  addSub: noop,
-  removeSub: noop
-} as Dep
-
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-export class Observer {
-  dep: Dep
-  vmCount: number // number of vms that have this object as root $data
-
-  constructor(public value: any, public shallow = false, public mock = false) {
-    // this.value = value
-    this.dep = mock ? mockDep : new Dep()
-    this.vmCount = 0
-    def(value, '__ob__', this)
-    if (isArray(value)) {
-      if (!mock) {
-        if (hasProto) {
-          /* eslint-disable no-proto */
-          ;(value as any).__proto__ = arrayMethods
-          /* eslint-enable no-proto */
-        } else {
-          for (let i = 0, l = arrayKeys.length; i < l; i++) {
-            const key = arrayKeys[i]
-            def(value, key, arrayMethods[key])
-          }
-        }
-      }
-      if (!shallow) {
-        this.observeArray(value)
-      }
-    } else {
-      /**
-       * Walk through all properties and convert them into
-       * getter/setters. This method should only be called when
-       * value type is Object.
-       */
-      const keys = Object.keys(value)
-      for (let i = 0; i < keys.length; i++) {
-        const key = keys[i]
-        defineReactive(value, key, NO_INIITIAL_VALUE, undefined, shallow, mock)
-      }
-    }
-  }
-
-  /**
-   * Observe a list of Array items.
-   */
-  observeArray(value: any[]) {
-    for (let i = 0, l = value.length; i < l; i++) {
-      observe(value[i], false, this.mock)
-    }
-  }
-}
-
-// helpers
-
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-export function observe(
-  value: any,
-  shallow?: boolean,
-  ssrMockReactivity?: boolean
-): Observer | void {
-  if (value && hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-    return value.__ob__
-  }
-  if (
-    shouldObserve &&
-    (ssrMockReactivity || !isServerRendering()) &&
-    (isArray(value) || isPlainObject(value)) &&
-    Object.isExtensible(value) &&
-    !value.__v_skip /* ReactiveFlags.SKIP */ &&
-    !isRef(value) &&
-    !(value instanceof VNode)
-  ) {
-    return new Observer(value, shallow, ssrMockReactivity)
-  }
-}
-
-/**
- * Define a reactive property on an Object.
- */
-export function defineReactive(
-  obj: object,
-  key: string,
-  val?: any,
-  customSetter?: Function | null,
-  shallow?: boolean,
-  mock?: boolean
-) {
-  const dep = new Dep()
-
-  const property = Object.getOwnPropertyDescriptor(obj, key)
-  if (property && property.configurable === false) {
-    return
-  }
-
-  // cater for pre-defined getter/setters
-  const getter = property && property.get
-  const setter = property && property.set
-  if (
-    (!getter || setter) &&
-    (val === NO_INIITIAL_VALUE || arguments.length === 2)
-  ) {
-    val = obj[key]
-  }
-
-  let childOb = !shallow && observe(val, false, mock)
-  Object.defineProperty(obj, key, {
-    enumerable: true,
-    configurable: true,
-    get: function reactiveGetter() {
-      const value = getter ? getter.call(obj) : val
-      if (Dep.target) {
-        if (__DEV__) {
-          dep.depend({
-            target: obj,
-            type: TrackOpTypes.GET,
-            key
-          })
-        } else {
-          dep.depend()
-        }
-        if (childOb) {
-          childOb.dep.depend()
-          if (isArray(value)) {
-            dependArray(value)
-          }
-        }
-      }
-      return isRef(value) && !shallow ? value.value : value
-    },
-    set: function reactiveSetter(newVal) {
-      const value = getter ? getter.call(obj) : val
-      if (!hasChanged(value, newVal)) {
-        return
-      }
-      if (__DEV__ && customSetter) {
-        customSetter()
-      }
-      if (setter) {
-        setter.call(obj, newVal)
-      } else if (getter) {
-        // #7981: for accessor properties without setter
-        return
-      } else if (!shallow && isRef(value) && !isRef(newVal)) {
-        value.value = newVal
-        return
-      } else {
-        val = newVal
-      }
-      childOb = !shallow && observe(newVal, false, mock)
-      if (__DEV__) {
-        dep.notify({
-          type: TriggerOpTypes.SET,
-          target: obj,
-          key,
-          newValue: newVal,
-          oldValue: value
-        })
-      } else {
-        dep.notify()
-      }
-    }
-  })
-
-  return dep
-}
-
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-export function set<T>(array: T[], key: number, value: T): T
-export function set<T>(object: object, key: string | number, value: T): T
-export function set(
-  target: any[] | Record<string, any>,
-  key: any,
-  val: any
-): any {
-  if (__DEV__ && (isUndef(target) || isPrimitive(target))) {
-    warn(
-      `Cannot set reactive property on undefined, null, or primitive value: ${target}`
-    )
-  }
-  if (isReadonly(target)) {
-    __DEV__ && warn(`Set operation on key "${key}" failed: target is readonly.`)
-    return
-  }
-  const ob = (target as any).__ob__
-  if (isArray(target) && isValidArrayIndex(key)) {
-    target.length = Math.max(target.length, key)
-    target.splice(key, 1, val)
-    // when mocking for SSR, array methods are not hijacked
-    if (ob && !ob.shallow && ob.mock) {
-      observe(val, false, true)
-    }
-    return val
-  }
-  if (key in target && !(key in Object.prototype)) {
-    target[key] = val
-    return val
-  }
-  if ((target as any)._isVue || (ob && ob.vmCount)) {
-    __DEV__ &&
-      warn(
-        'Avoid adding reactive properties to a Vue instance or its root $data ' +
-          'at runtime - declare it upfront in the data option.'
-      )
-    return val
-  }
-  if (!ob) {
-    target[key] = val
-    return val
-  }
-  defineReactive(ob.value, key, val, undefined, ob.shallow, ob.mock)
-  if (__DEV__) {
-    ob.dep.notify({
-      type: TriggerOpTypes.ADD,
-      target: target,
-      key,
-      newValue: val,
-      oldValue: undefined
-    })
-  } else {
-    ob.dep.notify()
-  }
-  return val
-}
-
-/**
- * Delete a property and trigger change if necessary.
- */
-export function del<T>(array: T[], key: number): void
-export function del(object: object, key: string | number): void
-export function del(target: any[] | object, key: any) {
-  if (__DEV__ && (isUndef(target) || isPrimitive(target))) {
-    warn(
-      `Cannot delete reactive property on undefined, null, or primitive value: ${target}`
-    )
-  }
-  if (isArray(target) && isValidArrayIndex(key)) {
-    target.splice(key, 1)
-    return
-  }
-  const ob = (target as any).__ob__
-  if ((target as any)._isVue || (ob && ob.vmCount)) {
-    __DEV__ &&
-      warn(
-        'Avoid deleting properties on a Vue instance or its root $data ' +
-          '- just set it to null.'
-      )
-    return
-  }
-  if (isReadonly(target)) {
-    __DEV__ &&
-      warn(`Delete operation on key "${key}" failed: target is readonly.`)
-    return
-  }
-  if (!hasOwn(target, key)) {
-    return
-  }
-  delete target[key]
-  if (!ob) {
-    return
-  }
-  if (__DEV__) {
-    ob.dep.notify({
-      type: TriggerOpTypes.DELETE,
-      target: target,
-      key
-    })
-  } else {
-    ob.dep.notify()
-  }
-}
-
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value: Array<any>) {
-  for (let e, i = 0, l = value.length; i < l; i++) {
-    e = value[i]
-    if (e && e.__ob__) {
-      e.__ob__.dep.depend()
-    }
-    if (isArray(e)) {
-      dependArray(e)
-    }
-  }
-}

package/vue2/node_modules/vue/src/core/observer/scheduler.ts

@@ -1,199 +0,0 @@
-import type Watcher from './watcher'
-import config from '../config'
-import Dep, { cleanupDeps } from './dep'
-import { callHook, activateChildComponent } from '../instance/lifecycle'
-
-import { warn, nextTick, devtools, inBrowser, isIE } from '../util/index'
-import type { Component } from 'types/component'
-
-export const MAX_UPDATE_COUNT = 100
-
-const queue: Array<Watcher> = []
-const activatedChildren: Array<Component> = []
-let has: { [key: number]: true | undefined | null } = {}
-let circular: { [key: number]: number } = {}
-let waiting = false
-let flushing = false
-let index = 0
-
-/**
- * Reset the scheduler's state.
- */
-function resetSchedulerState() {
-  index = queue.length = activatedChildren.length = 0
-  has = {}
-  if (__DEV__) {
-    circular = {}
-  }
-  waiting = flushing = false
-}
-
-// Async edge case #6566 requires saving the timestamp when event listeners are
-// attached. However, calling performance.now() has a perf overhead especially
-// if the page has thousands of event listeners. Instead, we take a timestamp
-// every time the scheduler flushes and use that for all event listeners
-// attached during that flush.
-export let currentFlushTimestamp = 0
-
-// Async edge case fix requires storing an event listener's attach timestamp.
-let getNow: () => number = Date.now
-
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-  const performance = window.performance
-  if (
-    performance &&
-    typeof performance.now === 'function' &&
-    getNow() > document.createEvent('Event').timeStamp
-  ) {
-    // if the event timestamp, although evaluated AFTER the Date.now(), is
-    // smaller than it, it means the event is using a hi-res timestamp,
-    // and we need to use the hi-res version for event listener timestamps as
-    // well.
-    getNow = () => performance.now()
-  }
-}
-
-const sortCompareFn = (a: Watcher, b: Watcher): number => {
-  if (a.post) {
-    if (!b.post) return 1
-  } else if (b.post) {
-    return -1
-  }
-  return a.id - b.id
-}
-
-/**
- * Flush both queues and run the watchers.
- */
-function flushSchedulerQueue() {
-  currentFlushTimestamp = getNow()
-  flushing = true
-  let watcher, id
-
-  // Sort queue before flush.
-  // This ensures that:
-  // 1. Components are updated from parent to child. (because parent is always
-  //    created before the child)
-  // 2. A component's user watchers are run before its render watcher (because
-  //    user watchers are created before the render watcher)
-  // 3. If a component is destroyed during a parent component's watcher run,
-  //    its watchers can be skipped.
-  queue.sort(sortCompareFn)
-
-  // do not cache length because more watchers might be pushed
-  // as we run existing watchers
-  for (index = 0; index < queue.length; index++) {
-    watcher = queue[index]
-    if (watcher.before) {
-      watcher.before()
-    }
-    id = watcher.id
-    has[id] = null
-    watcher.run()
-    // in dev build, check and stop circular updates.
-    if (__DEV__ && has[id] != null) {
-      circular[id] = (circular[id] || 0) + 1
-      if (circular[id] > MAX_UPDATE_COUNT) {
-        warn(
-          'You may have an infinite update loop ' +
-            (watcher.user
-              ? `in watcher with expression "${watcher.expression}"`
-              : `in a component render function.`),
-          watcher.vm
-        )
-        break
-      }
-    }
-  }
-
-  // keep copies of post queues before resetting state
-  const activatedQueue = activatedChildren.slice()
-  const updatedQueue = queue.slice()
-
-  resetSchedulerState()
-
-  // call component updated and activated hooks
-  callActivatedHooks(activatedQueue)
-  callUpdatedHooks(updatedQueue)
-  cleanupDeps()
-
-  // devtool hook
-  /* istanbul ignore if */
-  if (devtools && config.devtools) {
-    devtools.emit('flush')
-  }
-}
-
-function callUpdatedHooks(queue: Watcher[]) {
-  let i = queue.length
-  while (i--) {
-    const watcher = queue[i]
-    const vm = watcher.vm
-    if (vm && vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-      callHook(vm, 'updated')
-    }
-  }
-}
-
-/**
- * Queue a kept-alive component that was activated during patch.
- * The queue will be processed after the entire tree has been patched.
- */
-export function queueActivatedComponent(vm: Component) {
-  // setting _inactive to false here so that a render function can
-  // rely on checking whether it's in an inactive tree (e.g. router-view)
-  vm._inactive = false
-  activatedChildren.push(vm)
-}
-
-function callActivatedHooks(queue) {
-  for (let i = 0; i < queue.length; i++) {
-    queue[i]._inactive = true
-    activateChildComponent(queue[i], true /* true */)
-  }
-}
-
-/**
- * Push a watcher into the watcher queue.
- * Jobs with duplicate IDs will be skipped unless it's
- * pushed when the queue is being flushed.
- */
-export function queueWatcher(watcher: Watcher) {
-  const id = watcher.id
-  if (has[id] != null) {
-    return
-  }
-
-  if (watcher === Dep.target && watcher.noRecurse) {
-    return
-  }
-
-  has[id] = true
-  if (!flushing) {
-    queue.push(watcher)
-  } else {
-    // if already flushing, splice the watcher based on its id
-    // if already past its id, it will be run next immediately.
-    let i = queue.length - 1
-    while (i > index && queue[i].id > watcher.id) {
-      i--
-    }
-    queue.splice(i + 1, 0, watcher)
-  }
-  // queue the flush
-  if (!waiting) {
-    waiting = true
-
-    if (__DEV__ && !config.async) {
-      flushSchedulerQueue()
-      return
-    }
-    nextTick(flushSchedulerQueue)
-  }
-}

package/vue2/node_modules/vue/src/core/observer/traverse.ts

@@ -1,47 +0,0 @@
-import { _Set as Set, isObject, isArray } from '../util/index'
-import type { SimpleSet } from '../util/index'
-import VNode from '../vdom/vnode'
-import { isRef } from '../../v3'
-
-const seenObjects = new Set()
-
-/**
- * Recursively traverse an object to evoke all converted
- * getters, so that every nested property inside the object
- * is collected as a "deep" dependency.
- */
-export function traverse(val: any) {
-  _traverse(val, seenObjects)
-  seenObjects.clear()
-  return val
-}
-
-function _traverse(val: any, seen: SimpleSet) {
-  let i, keys
-  const isA = isArray(val)
-  if (
-    (!isA && !isObject(val)) ||
-    val.__v_skip /* ReactiveFlags.SKIP */ ||
-    Object.isFrozen(val) ||
-    val instanceof VNode
-  ) {
-    return
-  }
-  if (val.__ob__) {
-    const depId = val.__ob__.dep.id
-    if (seen.has(depId)) {
-      return
-    }
-    seen.add(depId)
-  }
-  if (isA) {
-    i = val.length
-    while (i--) _traverse(val[i], seen)
-  } else if (isRef(val)) {
-    _traverse(val.value, seen)
-  } else {
-    keys = Object.keys(val)
-    i = keys.length
-    while (i--) _traverse(val[keys[i]], seen)
-  }
-}