@builder.io/sdk-vue 0.5.9 → 0.6.1-0

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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,119 @@
+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

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

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

@@ -0,0 +1,165 @@
+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

@@ -0,0 +1,128 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,9 @@
+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

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