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

package/vue2/node_modules/vue/src/compiler/parser/text-parser.ts

@@ -1,52 +0,0 @@
-import { cached } from 'shared/util'
-import { parseFilters } from './filter-parser'
-
-const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g
-const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g
-
-const buildRegex = cached(delimiters => {
-  const open = delimiters[0].replace(regexEscapeRE, '\\$&')
-  const close = delimiters[1].replace(regexEscapeRE, '\\$&')
-  return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
-})
-
-type TextParseResult = {
-  expression: string
-  tokens: Array<string | { '@binding': string }>
-}
-
-export function parseText(
-  text: string,
-  delimiters?: [string, string]
-): TextParseResult | void {
-  //@ts-expect-error
-  const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE
-  if (!tagRE.test(text)) {
-    return
-  }
-  const tokens: string[] = []
-  const rawTokens: any[] = []
-  let lastIndex = (tagRE.lastIndex = 0)
-  let match, index, tokenValue
-  while ((match = tagRE.exec(text))) {
-    index = match.index
-    // push text token
-    if (index > lastIndex) {
-      rawTokens.push((tokenValue = text.slice(lastIndex, index)))
-      tokens.push(JSON.stringify(tokenValue))
-    }
-    // tag token
-    const exp = parseFilters(match[1].trim())
-    tokens.push(`_s(${exp})`)
-    rawTokens.push({ '@binding': exp })
-    lastIndex = index + match[0].length
-  }
-  if (lastIndex < text.length) {
-    rawTokens.push((tokenValue = text.slice(lastIndex)))
-    tokens.push(JSON.stringify(tokenValue))
-  }
-  return {
-    expression: tokens.join('+'),
-    tokens: rawTokens
-  }
-}

package/vue2/node_modules/vue/src/compiler/to-function.ts

@@ -1,119 +0,0 @@
-import { noop, extend } from 'shared/util'
-import { warn as baseWarn, tip } from 'core/util/debug'
-import { generateCodeFrame } from './codeframe'
-import type { Component } from 'types/component'
-import { CompilerOptions } from 'types/compiler'
-
-type CompiledFunctionResult = {
-  render: Function
-  staticRenderFns: Array<Function>
-}
-
-function createFunction(code, errors) {
-  try {
-    return new Function(code)
-  } catch (err: any) {
-    errors.push({ err, code })
-    return noop
-  }
-}
-
-export function createCompileToFunctionFn(compile: Function): Function {
-  const cache = Object.create(null)
-
-  return function compileToFunctions(
-    template: string,
-    options?: CompilerOptions,
-    vm?: Component
-  ): CompiledFunctionResult {
-    options = extend({}, options)
-    const warn = options.warn || baseWarn
-    delete options.warn
-
-    /* istanbul ignore if */
-    if (__DEV__) {
-      // detect possible CSP restriction
-      try {
-        new Function('return 1')
-      } catch (e: any) {
-        if (e.toString().match(/unsafe-eval|CSP/)) {
-          warn(
-            'It seems you are using the standalone build of Vue.js in an ' +
-              'environment with Content Security Policy that prohibits unsafe-eval. ' +
-              'The template compiler cannot work in this environment. Consider ' +
-              'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-              'templates into render functions.'
-          )
-        }
-      }
-    }
-
-    // check cache
-    const key = options.delimiters
-      ? String(options.delimiters) + template
-      : template
-    if (cache[key]) {
-      return cache[key]
-    }
-
-    // compile
-    const compiled = compile(template, options)
-
-    // check compilation errors/tips
-    if (__DEV__) {
-      if (compiled.errors && compiled.errors.length) {
-        if (options.outputSourceRange) {
-          compiled.errors.forEach(e => {
-            warn(
-              `Error compiling template:\n\n${e.msg}\n\n` +
-                generateCodeFrame(template, e.start, e.end),
-              vm
-            )
-          })
-        } else {
-          warn(
-            `Error compiling template:\n\n${template}\n\n` +
-              compiled.errors.map(e => `- ${e}`).join('\n') +
-              '\n',
-            vm
-          )
-        }
-      }
-      if (compiled.tips && compiled.tips.length) {
-        if (options.outputSourceRange) {
-          compiled.tips.forEach(e => tip(e.msg, vm))
-        } else {
-          compiled.tips.forEach(msg => tip(msg, vm))
-        }
-      }
-    }
-
-    // turn code into functions
-    const res: any = {}
-    const fnGenErrors: any[] = []
-    res.render = createFunction(compiled.render, fnGenErrors)
-    res.staticRenderFns = compiled.staticRenderFns.map(code => {
-      return createFunction(code, fnGenErrors)
-    })
-
-    // check function generation errors.
-    // this should only happen if there is a bug in the compiler itself.
-    // mostly for codegen development use
-    /* istanbul ignore if */
-    if (__DEV__) {
-      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-        warn(
-          `Failed to generate render function:\n\n` +
-            fnGenErrors
-              .map(
-                ({ err, code }) => `${(err as any).toString()} in\n\n${code}\n`
-              )
-              .join('\n'),
-          vm
-        )
-      }
-    }
-
-    return (cache[key] = res)
-  }
-}

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

@@ -1,5 +0,0 @@
-import KeepAlive from './keep-alive'
-
-export default {
-  KeepAlive
-}

package/vue2/node_modules/vue/src/core/components/keep-alive.ts

@@ -1,165 +0,0 @@
-import { isRegExp, isArray, remove } from 'shared/util'
-import { getFirstComponentChild } from 'core/vdom/helpers/index'
-import type VNode from 'core/vdom/vnode'
-import type { VNodeComponentOptions } from 'types/vnode'
-import type { Component } from 'types/component'
-import { getComponentName } from '../vdom/create-component'
-
-type CacheEntry = {
-  name?: string
-  tag?: string
-  componentInstance?: Component
-}
-
-type CacheEntryMap = Record<string, CacheEntry | null>
-
-function _getComponentName(opts?: VNodeComponentOptions): string | null {
-  return opts && (getComponentName(opts.Ctor.options as any) || opts.tag)
-}
-
-function matches(
-  pattern: string | RegExp | Array<string>,
-  name: string
-): boolean {
-  if (isArray(pattern)) {
-    return pattern.indexOf(name) > -1
-  } else if (typeof pattern === 'string') {
-    return pattern.split(',').indexOf(name) > -1
-  } else if (isRegExp(pattern)) {
-    return pattern.test(name)
-  }
-  /* istanbul ignore next */
-  return false
-}
-
-function pruneCache(
-  keepAliveInstance: { cache: CacheEntryMap; keys: string[]; _vnode: VNode },
-  filter: Function
-) {
-  const { cache, keys, _vnode } = keepAliveInstance
-  for (const key in cache) {
-    const entry = cache[key]
-    if (entry) {
-      const name = entry.name
-      if (name && !filter(name)) {
-        pruneCacheEntry(cache, key, keys, _vnode)
-      }
-    }
-  }
-}
-
-function pruneCacheEntry(
-  cache: CacheEntryMap,
-  key: string,
-  keys: Array<string>,
-  current?: VNode
-) {
-  const entry = cache[key]
-  if (entry && (!current || entry.tag !== current.tag)) {
-    // @ts-expect-error can be undefined
-    entry.componentInstance.$destroy()
-  }
-  cache[key] = null
-  remove(keys, key)
-}
-
-const patternTypes: Array<Function> = [String, RegExp, Array]
-
-// TODO defineComponent
-export default {
-  name: 'keep-alive',
-  abstract: true,
-
-  props: {
-    include: patternTypes,
-    exclude: patternTypes,
-    max: [String, Number]
-  },
-
-  methods: {
-    cacheVNode() {
-      const { cache, keys, vnodeToCache, keyToCache } = this
-      if (vnodeToCache) {
-        const { tag, componentInstance, componentOptions } = vnodeToCache
-        cache[keyToCache] = {
-          name: _getComponentName(componentOptions),
-          tag,
-          componentInstance
-        }
-        keys.push(keyToCache)
-        // prune oldest entry
-        if (this.max && keys.length > parseInt(this.max)) {
-          pruneCacheEntry(cache, keys[0], keys, this._vnode)
-        }
-        this.vnodeToCache = null
-      }
-    }
-  },
-
-  created() {
-    this.cache = Object.create(null)
-    this.keys = []
-  },
-
-  destroyed() {
-    for (const key in this.cache) {
-      pruneCacheEntry(this.cache, key, this.keys)
-    }
-  },
-
-  mounted() {
-    this.cacheVNode()
-    this.$watch('include', val => {
-      pruneCache(this, name => matches(val, name))
-    })
-    this.$watch('exclude', val => {
-      pruneCache(this, name => !matches(val, name))
-    })
-  },
-
-  updated() {
-    this.cacheVNode()
-  },
-
-  render() {
-    const slot = this.$slots.default
-    const vnode = getFirstComponentChild(slot)
-    const componentOptions = vnode && vnode.componentOptions
-    if (componentOptions) {
-      // check pattern
-      const name = _getComponentName(componentOptions)
-      const { include, exclude } = this
-      if (
-        // not included
-        (include && (!name || !matches(include, name))) ||
-        // excluded
-        (exclude && name && matches(exclude, name))
-      ) {
-        return vnode
-      }
-
-      const { cache, keys } = this
-      const key =
-        vnode.key == null
-          ? // same constructor may get registered as different local components
-            // so cid alone is not enough (#3269)
-            componentOptions.Ctor.cid +
-            (componentOptions.tag ? `::${componentOptions.tag}` : '')
-          : vnode.key
-      if (cache[key]) {
-        vnode.componentInstance = cache[key].componentInstance
-        // make current key freshest
-        remove(keys, key)
-        keys.push(key)
-      } else {
-        // delay setting the cache until update
-        this.vnodeToCache = vnode
-        this.keyToCache = key
-      }
-
-      // @ts-expect-error can vnode.data can be undefined
-      vnode.data.keepAlive = true
-    }
-    return vnode || (slot && slot[0])
-  }
-}

package/vue2/node_modules/vue/src/core/config.ts

@@ -1,128 +0,0 @@
-import { no, noop, identity } from 'shared/util'
-
-import { LIFECYCLE_HOOKS } from 'shared/constants'
-import type { Component } from 'types/component'
-
-/**
- * @internal
- */
-export interface Config {
-  // user
-  optionMergeStrategies: { [key: string]: Function }
-  silent: boolean
-  productionTip: boolean
-  performance: boolean
-  devtools: boolean
-  errorHandler?: (err: Error, vm: Component | null, info: string) => void
-  warnHandler?: (msg: string, vm: Component | null, trace: string) => void
-  ignoredElements: Array<string | RegExp>
-  keyCodes: { [key: string]: number | Array<number> }
-
-  // platform
-  isReservedTag: (x: string) => boolean | undefined
-  isReservedAttr: (x: string) => true | undefined
-  parsePlatformTagName: (x: string) => string
-  isUnknownElement: (x: string) => boolean
-  getTagNamespace: (x: string) => string | undefined
-  mustUseProp: (tag: string, type?: string | null, name?: string) => boolean
-
-  // private
-  async: boolean
-
-  // legacy
-  _lifecycleHooks: Array<string>
-}
-
-export default {
-  /**
-   * Option merge strategies (used in core/util/options)
-   */
-  // $flow-disable-line
-  optionMergeStrategies: Object.create(null),
-
-  /**
-   * Whether to suppress warnings.
-   */
-  silent: false,
-
-  /**
-   * Show production mode tip message on boot?
-   */
-  productionTip: __DEV__,
-
-  /**
-   * Whether to enable devtools
-   */
-  devtools: __DEV__,
-
-  /**
-   * Whether to record perf
-   */
-  performance: false,
-
-  /**
-   * Error handler for watcher errors
-   */
-  errorHandler: null,
-
-  /**
-   * Warn handler for watcher warns
-   */
-  warnHandler: null,
-
-  /**
-   * Ignore certain custom elements
-   */
-  ignoredElements: [],
-
-  /**
-   * Custom user key aliases for v-on
-   */
-  // $flow-disable-line
-  keyCodes: Object.create(null),
-
-  /**
-   * Check if a tag is reserved so that it cannot be registered as a
-   * component. This is platform-dependent and may be overwritten.
-   */
-  isReservedTag: no,
-
-  /**
-   * Check if an attribute is reserved so that it cannot be used as a component
-   * prop. This is platform-dependent and may be overwritten.
-   */
-  isReservedAttr: no,
-
-  /**
-   * Check if a tag is an unknown element.
-   * Platform-dependent.
-   */
-  isUnknownElement: no,
-
-  /**
-   * Get the namespace of an element
-   */
-  getTagNamespace: noop,
-
-  /**
-   * Parse the real tag name for the specific platform.
-   */
-  parsePlatformTagName: identity,
-
-  /**
-   * Check if an attribute must be bound using property, e.g. value
-   * Platform-dependent.
-   */
-  mustUseProp: no,
-
-  /**
-   * Perform updates asynchronously. Intended to be used by Vue Test Utils
-   * This will significantly reduce performance if set to false.
-   */
-  async: true,
-
-  /**
-   * Exposed for legacy reasons
-   */
-  _lifecycleHooks: LIFECYCLE_HOOKS
-} as unknown as Config

package/vue2/node_modules/vue/src/core/global-api/assets.ts

@@ -1,35 +0,0 @@
-import { ASSET_TYPES } from 'shared/constants'
-import type { GlobalAPI } from 'types/global-api'
-import { isFunction, isPlainObject, validateComponentName } from '../util/index'
-
-export function initAssetRegisters(Vue: GlobalAPI) {
-  /**
-   * Create asset registration methods.
-   */
-  ASSET_TYPES.forEach(type => {
-    // @ts-expect-error function is not exact same type
-    Vue[type] = function (
-      id: string,
-      definition?: Function | Object
-    ): Function | Object | void {
-      if (!definition) {
-        return this.options[type + 's'][id]
-      } else {
-        /* istanbul ignore if */
-        if (__DEV__ && type === 'component') {
-          validateComponentName(id)
-        }
-        if (type === 'component' && isPlainObject(definition)) {
-          // @ts-expect-error
-          definition.name = definition.name || id
-          definition = this.options._base.extend(definition)
-        }
-        if (type === 'directive' && isFunction(definition)) {
-          definition = { bind: definition, update: definition }
-        }
-        this.options[type + 's'][id] = definition
-        return definition
-      }
-    }
-  })
-}

package/vue2/node_modules/vue/src/core/global-api/extend.ts

@@ -1,94 +0,0 @@
-import { ASSET_TYPES } from 'shared/constants'
-import type { Component } from 'types/component'
-import type { GlobalAPI } from 'types/global-api'
-import { defineComputed, proxy } from '../instance/state'
-import { extend, mergeOptions, validateComponentName } from '../util/index'
-import { getComponentName } from '../vdom/create-component'
-
-export function initExtend(Vue: GlobalAPI) {
-  /**
-   * Each instance constructor, including Vue, has a unique
-   * cid. This enables us to create wrapped "child
-   * constructors" for prototypal inheritance and cache them.
-   */
-  Vue.cid = 0
-  let cid = 1
-
-  /**
-   * Class inheritance
-   */
-  Vue.extend = function (extendOptions: any): typeof Component {
-    extendOptions = extendOptions || {}
-    const Super = this
-    const SuperId = Super.cid
-    const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {})
-    if (cachedCtors[SuperId]) {
-      return cachedCtors[SuperId]
-    }
-
-    const name =
-      getComponentName(extendOptions) || getComponentName(Super.options)
-    if (__DEV__ && name) {
-      validateComponentName(name)
-    }
-
-    const Sub = function VueComponent(this: any, options: any) {
-      this._init(options)
-    } as unknown as typeof Component
-    Sub.prototype = Object.create(Super.prototype)
-    Sub.prototype.constructor = Sub
-    Sub.cid = cid++
-    Sub.options = mergeOptions(Super.options, extendOptions)
-    Sub['super'] = Super
-
-    // For props and computed properties, we define the proxy getters on
-    // the Vue instances at extension time, on the extended prototype. This
-    // avoids Object.defineProperty calls for each instance created.
-    if (Sub.options.props) {
-      initProps(Sub)
-    }
-    if (Sub.options.computed) {
-      initComputed(Sub)
-    }
-
-    // allow further extension/mixin/plugin usage
-    Sub.extend = Super.extend
-    Sub.mixin = Super.mixin
-    Sub.use = Super.use
-
-    // create asset registers, so extended classes
-    // can have their private assets too.
-    ASSET_TYPES.forEach(function (type) {
-      Sub[type] = Super[type]
-    })
-    // enable recursive self-lookup
-    if (name) {
-      Sub.options.components[name] = Sub
-    }
-
-    // keep a reference to the super options at extension time.
-    // later at instantiation we can check if Super's options have
-    // been updated.
-    Sub.superOptions = Super.options
-    Sub.extendOptions = extendOptions
-    Sub.sealedOptions = extend({}, Sub.options)
-
-    // cache constructor
-    cachedCtors[SuperId] = Sub
-    return Sub
-  }
-}
-
-function initProps(Comp: typeof Component) {
-  const props = Comp.options.props
-  for (const key in props) {
-    proxy(Comp.prototype, `_props`, key)
-  }
-}
-
-function initComputed(Comp: typeof Component) {
-  const computed = Comp.options.computed
-  for (const key in computed) {
-    defineComputed(Comp.prototype, key, computed[key])
-  }
-}

package/vue2/node_modules/vue/src/core/global-api/index.ts

@@ -1,68 +0,0 @@
-import config from '../config'
-import { initUse } from './use'
-import { initMixin } from './mixin'
-import { initExtend } from './extend'
-import { initAssetRegisters } from './assets'
-import { set, del } from '../observer/index'
-import { ASSET_TYPES } from 'shared/constants'
-import builtInComponents from '../components/index'
-import { observe } from 'core/observer/index'
-
-import {
-  warn,
-  extend,
-  nextTick,
-  mergeOptions,
-  defineReactive
-} from '../util/index'
-import type { GlobalAPI } from 'types/global-api'
-
-export function initGlobalAPI(Vue: GlobalAPI) {
-  // config
-  const configDef: Record<string, any> = {}
-  configDef.get = () => config
-  if (__DEV__) {
-    configDef.set = () => {
-      warn(
-        'Do not replace the Vue.config object, set individual fields instead.'
-      )
-    }
-  }
-  Object.defineProperty(Vue, 'config', configDef)
-
-  // exposed util methods.
-  // NOTE: these are not considered part of the public API - avoid relying on
-  // them unless you are aware of the risk.
-  Vue.util = {
-    warn,
-    extend,
-    mergeOptions,
-    defineReactive
-  }
-
-  Vue.set = set
-  Vue.delete = del
-  Vue.nextTick = nextTick
-
-  // 2.6 explicit observable API
-  Vue.observable = <T>(obj: T): T => {
-    observe(obj)
-    return obj
-  }
-
-  Vue.options = Object.create(null)
-  ASSET_TYPES.forEach(type => {
-    Vue.options[type + 's'] = Object.create(null)
-  })
-
-  // this is used to identify the "base" constructor to extend all plain-object
-  // components with in Weex's multi-instance scenarios.
-  Vue.options._base = Vue
-
-  extend(Vue.options.components, builtInComponents)
-
-  initUse(Vue)
-  initMixin(Vue)
-  initExtend(Vue)
-  initAssetRegisters(Vue)
-}

package/vue2/node_modules/vue/src/core/global-api/mixin.ts

@@ -1,9 +0,0 @@
-import type { GlobalAPI } from 'types/global-api'
-import { mergeOptions } from '../util/index'
-
-export function initMixin(Vue: GlobalAPI) {
-  Vue.mixin = function (mixin: Object) {
-    this.options = mergeOptions(this.options, mixin)
-    return this
-  }
-}

package/vue2/node_modules/vue/src/core/global-api/use.ts

@@ -1,23 +0,0 @@
-import type { GlobalAPI } from 'types/global-api'
-import { toArray, isFunction } from '../util/index'
-
-export function initUse(Vue: GlobalAPI) {
-  Vue.use = function (plugin: Function | any) {
-    const installedPlugins =
-      this._installedPlugins || (this._installedPlugins = [])
-    if (installedPlugins.indexOf(plugin) > -1) {
-      return this
-    }
-
-    // additional parameters
-    const args = toArray(arguments, 1)
-    args.unshift(this)
-    if (isFunction(plugin.install)) {
-      plugin.install.apply(plugin, args)
-    } else if (isFunction(plugin)) {
-      plugin.apply(null, args)
-    }
-    installedPlugins.push(plugin)
-    return this
-  }
-}