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

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

@@ -1,278 +0,0 @@
-import {
-  warn,
-  remove,
-  isObject,
-  parsePath,
-  _Set as Set,
-  handleError,
-  invokeWithErrorHandling,
-  noop,
-  isFunction
-} from '../util/index'
-
-import { traverse } from './traverse'
-import { queueWatcher } from './scheduler'
-import Dep, { pushTarget, popTarget, DepTarget } from './dep'
-import { DebuggerEvent, DebuggerOptions } from 'v3/debug'
-
-import type { SimpleSet } from '../util/index'
-import type { Component } from 'types/component'
-import { activeEffectScope, recordEffectScope } from 'v3/reactivity/effectScope'
-
-let uid = 0
-
-/**
- * @internal
- */
-export interface WatcherOptions extends DebuggerOptions {
-  deep?: boolean
-  user?: boolean
-  lazy?: boolean
-  sync?: boolean
-  before?: Function
-}
-
-/**
- * A watcher parses an expression, collects dependencies,
- * and fires callback when the expression value changes.
- * This is used for both the $watch() api and directives.
- * @internal
- */
-export default class Watcher implements DepTarget {
-  vm?: Component | null
-  expression: string
-  cb: Function
-  id: number
-  deep: boolean
-  user: boolean
-  lazy: boolean
-  sync: boolean
-  dirty: boolean
-  active: boolean
-  deps: Array<Dep>
-  newDeps: Array<Dep>
-  depIds: SimpleSet
-  newDepIds: SimpleSet
-  before?: Function
-  onStop?: Function
-  noRecurse?: boolean
-  getter: Function
-  value: any
-  post: boolean
-
-  // dev only
-  onTrack?: ((event: DebuggerEvent) => void) | undefined
-  onTrigger?: ((event: DebuggerEvent) => void) | undefined
-
-  constructor(
-    vm: Component | null,
-    expOrFn: string | (() => any),
-    cb: Function,
-    options?: WatcherOptions | null,
-    isRenderWatcher?: boolean
-  ) {
-    recordEffectScope(
-      this,
-      // if the active effect scope is manually created (not a component scope),
-      // prioritize it
-      activeEffectScope && !activeEffectScope._vm
-        ? activeEffectScope
-        : vm
-        ? vm._scope
-        : undefined
-    )
-    if ((this.vm = vm) && isRenderWatcher) {
-      vm._watcher = this
-    }
-    // options
-    if (options) {
-      this.deep = !!options.deep
-      this.user = !!options.user
-      this.lazy = !!options.lazy
-      this.sync = !!options.sync
-      this.before = options.before
-      if (__DEV__) {
-        this.onTrack = options.onTrack
-        this.onTrigger = options.onTrigger
-      }
-    } else {
-      this.deep = this.user = this.lazy = this.sync = false
-    }
-    this.cb = cb
-    this.id = ++uid // uid for batching
-    this.active = true
-    this.post = false
-    this.dirty = this.lazy // for lazy watchers
-    this.deps = []
-    this.newDeps = []
-    this.depIds = new Set()
-    this.newDepIds = new Set()
-    this.expression = __DEV__ ? expOrFn.toString() : ''
-    // parse expression for getter
-    if (isFunction(expOrFn)) {
-      this.getter = expOrFn
-    } else {
-      this.getter = parsePath(expOrFn)
-      if (!this.getter) {
-        this.getter = noop
-        __DEV__ &&
-          warn(
-            `Failed watching path: "${expOrFn}" ` +
-              'Watcher only accepts simple dot-delimited paths. ' +
-              'For full control, use a function instead.',
-            vm
-          )
-      }
-    }
-    this.value = this.lazy ? undefined : this.get()
-  }
-
-  /**
-   * Evaluate the getter, and re-collect dependencies.
-   */
-  get() {
-    pushTarget(this)
-    let value
-    const vm = this.vm
-    try {
-      value = this.getter.call(vm, vm)
-    } catch (e: any) {
-      if (this.user) {
-        handleError(e, vm, `getter for watcher "${this.expression}"`)
-      } else {
-        throw e
-      }
-    } finally {
-      // "touch" every property so they are all tracked as
-      // dependencies for deep watching
-      if (this.deep) {
-        traverse(value)
-      }
-      popTarget()
-      this.cleanupDeps()
-    }
-    return value
-  }
-
-  /**
-   * Add a dependency to this directive.
-   */
-  addDep(dep: Dep) {
-    const id = dep.id
-    if (!this.newDepIds.has(id)) {
-      this.newDepIds.add(id)
-      this.newDeps.push(dep)
-      if (!this.depIds.has(id)) {
-        dep.addSub(this)
-      }
-    }
-  }
-
-  /**
-   * Clean up for dependency collection.
-   */
-  cleanupDeps() {
-    let i = this.deps.length
-    while (i--) {
-      const dep = this.deps[i]
-      if (!this.newDepIds.has(dep.id)) {
-        dep.removeSub(this)
-      }
-    }
-    let tmp: any = this.depIds
-    this.depIds = this.newDepIds
-    this.newDepIds = tmp
-    this.newDepIds.clear()
-    tmp = this.deps
-    this.deps = this.newDeps
-    this.newDeps = tmp
-    this.newDeps.length = 0
-  }
-
-  /**
-   * Subscriber interface.
-   * Will be called when a dependency changes.
-   */
-  update() {
-    /* istanbul ignore else */
-    if (this.lazy) {
-      this.dirty = true
-    } else if (this.sync) {
-      this.run()
-    } else {
-      queueWatcher(this)
-    }
-  }
-
-  /**
-   * Scheduler job interface.
-   * Will be called by the scheduler.
-   */
-  run() {
-    if (this.active) {
-      const value = this.get()
-      if (
-        value !== this.value ||
-        // Deep watchers and watchers on Object/Arrays should fire even
-        // when the value is the same, because the value may
-        // have mutated.
-        isObject(value) ||
-        this.deep
-      ) {
-        // set new value
-        const oldValue = this.value
-        this.value = value
-        if (this.user) {
-          const info = `callback for watcher "${this.expression}"`
-          invokeWithErrorHandling(
-            this.cb,
-            this.vm,
-            [value, oldValue],
-            this.vm,
-            info
-          )
-        } else {
-          this.cb.call(this.vm, value, oldValue)
-        }
-      }
-    }
-  }
-
-  /**
-   * Evaluate the value of the watcher.
-   * This only gets called for lazy watchers.
-   */
-  evaluate() {
-    this.value = this.get()
-    this.dirty = false
-  }
-
-  /**
-   * Depend on all deps collected by this watcher.
-   */
-  depend() {
-    let i = this.deps.length
-    while (i--) {
-      this.deps[i].depend()
-    }
-  }
-
-  /**
-   * Remove self from all dependencies' subscriber list.
-   */
-  teardown() {
-    if (this.vm && !this.vm._isBeingDestroyed) {
-      remove(this.vm._scope.effects, this)
-    }
-    if (this.active) {
-      let i = this.deps.length
-      while (i--) {
-        this.deps[i].removeSub(this)
-      }
-      this.active = false
-      if (this.onStop) {
-        this.onStop()
-      }
-    }
-  }
-}

package/vue2/node_modules/vue/src/core/util/debug.ts

@@ -1,105 +0,0 @@
-import config from '../config'
-import { noop, isArray, isFunction } from 'shared/util'
-import type { Component } from 'types/component'
-import { currentInstance } from 'v3/currentInstance'
-import { getComponentName } from '../vdom/create-component'
-
-export let warn: (msg: string, vm?: Component | null) => void = noop
-export let tip = noop
-export let generateComponentTrace: (vm: Component) => string // work around flow check
-export let formatComponentName: (vm: Component, includeFile?: false) => string
-
-if (__DEV__) {
-  const hasConsole = typeof console !== 'undefined'
-  const classifyRE = /(?:^|[-_])(\w)/g
-  const classify = str =>
-    str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '')
-
-  warn = (msg, vm = currentInstance) => {
-    const trace = vm ? generateComponentTrace(vm) : ''
-
-    if (config.warnHandler) {
-      config.warnHandler.call(null, msg, vm, trace)
-    } else if (hasConsole && !config.silent) {
-      console.error(`[Vue warn]: ${msg}${trace}`)
-    }
-  }
-
-  tip = (msg, vm) => {
-    if (hasConsole && !config.silent) {
-      console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''))
-    }
-  }
-
-  formatComponentName = (vm, includeFile) => {
-    if (vm.$root === vm) {
-      return '<Root>'
-    }
-    const options =
-      isFunction(vm) && (vm as any).cid != null
-        ? (vm as any).options
-        : vm._isVue
-        ? vm.$options || (vm.constructor as any).options
-        : vm
-    let name = getComponentName(options)
-    const file = options.__file
-    if (!name && file) {
-      const match = file.match(/([^/\\]+)\.vue$/)
-      name = match && match[1]
-    }
-
-    return (
-      (name ? `<${classify(name)}>` : `<Anonymous>`) +
-      (file && includeFile !== false ? ` at ${file}` : '')
-    )
-  }
-
-  const repeat = (str, n) => {
-    let res = ''
-    while (n) {
-      if (n % 2 === 1) res += str
-      if (n > 1) str += str
-      n >>= 1
-    }
-    return res
-  }
-
-  generateComponentTrace = (vm: Component | undefined) => {
-    if ((vm as any)._isVue && vm!.$parent) {
-      const tree: any[] = []
-      let currentRecursiveSequence = 0
-      while (vm) {
-        if (tree.length > 0) {
-          const last = tree[tree.length - 1]
-          if (last.constructor === vm.constructor) {
-            currentRecursiveSequence++
-            vm = vm.$parent!
-            continue
-          } else if (currentRecursiveSequence > 0) {
-            tree[tree.length - 1] = [last, currentRecursiveSequence]
-            currentRecursiveSequence = 0
-          }
-        }
-        tree.push(vm)
-        vm = vm.$parent!
-      }
-      return (
-        '\n\nfound in\n\n' +
-        tree
-          .map(
-            (vm, i) =>
-              `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${
-                isArray(vm)
-                  ? `${formatComponentName(vm[0])}... (${
-                      vm[1]
-                    } recursive calls)`
-                  : formatComponentName(vm)
-              }`
-          )
-          .join('\n')
-      )
-    } else {
-      return `\n\n(found in ${formatComponentName(vm!)})`
-    }
-  }
-}

package/vue2/node_modules/vue/src/core/util/env.ts

@@ -1,93 +0,0 @@
-// can we use __proto__?
-export const hasProto = '__proto__' in {}
-
-// Browser environment sniffing
-export const inBrowser = typeof window !== 'undefined'
-export const UA = inBrowser && window.navigator.userAgent.toLowerCase()
-export const isIE = UA && /msie|trident/.test(UA)
-export const isIE9 = UA && UA.indexOf('msie 9.0') > 0
-export const isEdge = UA && UA.indexOf('edge/') > 0
-export const isAndroid = UA && UA.indexOf('android') > 0
-export const isIOS = UA && /iphone|ipad|ipod|ios/.test(UA)
-export const isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge
-export const isPhantomJS = UA && /phantomjs/.test(UA)
-export const isFF = UA && UA.match(/firefox\/(\d+)/)
-
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-export const nativeWatch = {}.watch
-
-export let supportsPassive = false
-if (inBrowser) {
-  try {
-    const opts = {}
-    Object.defineProperty(opts, 'passive', {
-      get() {
-        /* istanbul ignore next */
-        supportsPassive = true
-      }
-    } as object) // https://github.com/facebook/flow/issues/285
-    window.addEventListener('test-passive', null as any, opts)
-  } catch (e: any) {}
-}
-
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer
-export const isServerRendering = () => {
-  if (_isServer === undefined) {
-    /* istanbul ignore if */
-    if (!inBrowser && typeof global !== 'undefined') {
-      // detect presence of vue-server-renderer and avoid
-      // Webpack shimming the process
-      _isServer =
-        global['process'] && global['process'].env.VUE_ENV === 'server'
-    } else {
-      _isServer = false
-    }
-  }
-  return _isServer
-}
-
-// detect devtools
-export const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__
-
-/* istanbul ignore next */
-export function isNative(Ctor: any): boolean {
-  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-}
-
-export const hasSymbol =
-  typeof Symbol !== 'undefined' &&
-  isNative(Symbol) &&
-  typeof Reflect !== 'undefined' &&
-  isNative(Reflect.ownKeys)
-
-let _Set // $flow-disable-line
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-  // use native Set when available.
-  _Set = Set
-} else {
-  // a non-standard Set polyfill that only works with primitive keys.
-  _Set = class Set implements SimpleSet {
-    set: Record<string, boolean> = Object.create(null)
-
-    has(key: string | number) {
-      return this.set[key] === true
-    }
-    add(key: string | number) {
-      this.set[key] = true
-    }
-    clear() {
-      this.set = Object.create(null)
-    }
-  }
-}
-
-export interface SimpleSet {
-  has(key: string | number): boolean
-  add(key: string | number): any
-  clear(): void
-}
-
-export { _Set }

package/vue2/node_modules/vue/src/core/util/error.ts

@@ -1,81 +0,0 @@
-import config from '../config'
-import { warn } from './debug'
-import { inBrowser } from './env'
-import { isPromise } from 'shared/util'
-import { pushTarget, popTarget } from '../observer/dep'
-
-export function handleError(err: Error, vm: any, info: string) {
-  // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-  // See: https://github.com/vuejs/vuex/issues/1505
-  pushTarget()
-  try {
-    if (vm) {
-      let cur = vm
-      while ((cur = cur.$parent)) {
-        const hooks = cur.$options.errorCaptured
-        if (hooks) {
-          for (let i = 0; i < hooks.length; i++) {
-            try {
-              const capture = hooks[i].call(cur, err, vm, info) === false
-              if (capture) return
-            } catch (e: any) {
-              globalHandleError(e, cur, 'errorCaptured hook')
-            }
-          }
-        }
-      }
-    }
-    globalHandleError(err, vm, info)
-  } finally {
-    popTarget()
-  }
-}
-
-export function invokeWithErrorHandling(
-  handler: Function,
-  context: any,
-  args: null | any[],
-  vm: any,
-  info: string
-) {
-  let res
-  try {
-    res = args ? handler.apply(context, args) : handler.call(context)
-    if (res && !res._isVue && isPromise(res) && !(res as any)._handled) {
-      res.catch(e => handleError(e, vm, info + ` (Promise/async)`))
-      // issue #9511
-      // avoid catch triggering multiple times when nested calls
-      ;(res as any)._handled = true
-    }
-  } catch (e: any) {
-    handleError(e, vm, info)
-  }
-  return res
-}
-
-function globalHandleError(err, vm, info) {
-  if (config.errorHandler) {
-    try {
-      return config.errorHandler.call(null, err, vm, info)
-    } catch (e: any) {
-      // if the user intentionally throws the original error in the handler,
-      // do not log it twice
-      if (e !== err) {
-        logError(e, null, 'config.errorHandler')
-      }
-    }
-  }
-  logError(err, vm, info)
-}
-
-function logError(err, vm, info) {
-  if (__DEV__) {
-    warn(`Error in ${info}: "${err.toString()}"`, vm)
-  }
-  /* istanbul ignore else */
-  if (inBrowser && typeof console !== 'undefined') {
-    console.error(err)
-  } else {
-    throw err
-  }
-}

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

@@ -1,9 +0,0 @@
-export * from 'shared/util'
-export * from './lang'
-export * from './env'
-export * from './options'
-export * from './debug'
-export * from './props'
-export * from './error'
-export * from './next-tick'
-export { defineReactive } from '../observer/index'

package/vue2/node_modules/vue/src/core/util/lang.ts

@@ -1,45 +0,0 @@
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-export const unicodeRegExp =
-  /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/
-
-/**
- * Check if a string starts with $ or _
- */
-export function isReserved(str: string): boolean {
-  const c = (str + '').charCodeAt(0)
-  return c === 0x24 || c === 0x5f
-}
-
-/**
- * Define a property.
- */
-export function def(obj: Object, key: string, val: any, enumerable?: boolean) {
-  Object.defineProperty(obj, key, {
-    value: val,
-    enumerable: !!enumerable,
-    writable: true,
-    configurable: true
-  })
-}
-
-/**
- * Parse simple path.
- */
-const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`)
-export function parsePath(path: string): any {
-  if (bailRE.test(path)) {
-    return
-  }
-  const segments = path.split('.')
-  return function (obj) {
-    for (let i = 0; i < segments.length; i++) {
-      if (!obj) return
-      obj = obj[segments[i]]
-    }
-    return obj
-  }
-}