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

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

@@ -1,254 +0,0 @@
-import { warn } from './debug'
-import { observe, toggleObserving, shouldObserve } from '../observer/index'
-import {
-  hasOwn,
-  isArray,
-  isObject,
-  isFunction,
-  toRawType,
-  hyphenate,
-  capitalize,
-  isPlainObject
-} from 'shared/util'
-import type { Component } from 'types/component'
-
-type PropOptions = {
-  type: Function | Array<Function> | null
-  default: any
-  required?: boolean
-  validator?: Function
-}
-
-export function validateProp(
-  key: string,
-  propOptions: Object,
-  propsData: Object,
-  vm?: Component
-): any {
-  const prop = propOptions[key]
-  const absent = !hasOwn(propsData, key)
-  let value = propsData[key]
-  // boolean casting
-  const booleanIndex = getTypeIndex(Boolean, prop.type)
-  if (booleanIndex > -1) {
-    if (absent && !hasOwn(prop, 'default')) {
-      value = false
-    } else if (value === '' || value === hyphenate(key)) {
-      // only cast empty string / same name to boolean if
-      // boolean has higher priority
-      const stringIndex = getTypeIndex(String, prop.type)
-      if (stringIndex < 0 || booleanIndex < stringIndex) {
-        value = true
-      }
-    }
-  }
-  // check default value
-  if (value === undefined) {
-    value = getPropDefaultValue(vm, prop, key)
-    // since the default value is a fresh copy,
-    // make sure to observe it.
-    const prevShouldObserve = shouldObserve
-    toggleObserving(true)
-    observe(value)
-    toggleObserving(prevShouldObserve)
-  }
-  if (__DEV__) {
-    assertProp(prop, key, value, vm, absent)
-  }
-  return value
-}
-
-/**
- * Get the default value of a prop.
- */
-function getPropDefaultValue(
-  vm: Component | undefined,
-  prop: PropOptions,
-  key: string
-): any {
-  // no default, return undefined
-  if (!hasOwn(prop, 'default')) {
-    return undefined
-  }
-  const def = prop.default
-  // warn against non-factory defaults for Object & Array
-  if (__DEV__ && isObject(def)) {
-    warn(
-      'Invalid default value for prop "' +
-        key +
-        '": ' +
-        'Props with type Object/Array must use a factory function ' +
-        'to return the default value.',
-      vm
-    )
-  }
-  // the raw prop value was also undefined from previous render,
-  // return previous default value to avoid unnecessary watcher trigger
-  if (
-    vm &&
-    vm.$options.propsData &&
-    vm.$options.propsData[key] === undefined &&
-    vm._props[key] !== undefined
-  ) {
-    return vm._props[key]
-  }
-  // call factory function for non-Function types
-  // a value is Function if its prototype is function even across different execution context
-  return isFunction(def) && getType(prop.type) !== 'Function'
-    ? def.call(vm)
-    : def
-}
-
-/**
- * Assert whether a prop is valid.
- */
-function assertProp(
-  prop: PropOptions,
-  name: string,
-  value: any,
-  vm?: Component,
-  absent?: boolean
-) {
-  if (prop.required && absent) {
-    warn('Missing required prop: "' + name + '"', vm)
-    return
-  }
-  if (value == null && !prop.required) {
-    return
-  }
-  let type = prop.type
-  let valid = !type || (type as any) === true
-  const expectedTypes: string[] = []
-  if (type) {
-    if (!isArray(type)) {
-      type = [type]
-    }
-    for (let i = 0; i < type.length && !valid; i++) {
-      const assertedType = assertType(value, type[i], vm)
-      expectedTypes.push(assertedType.expectedType || '')
-      valid = assertedType.valid
-    }
-  }
-
-  const haveExpectedTypes = expectedTypes.some(t => t)
-  if (!valid && haveExpectedTypes) {
-    warn(getInvalidTypeMessage(name, value, expectedTypes), vm)
-    return
-  }
-  const validator = prop.validator
-  if (validator) {
-    if (!validator(value)) {
-      warn(
-        'Invalid prop: custom validator check failed for prop "' + name + '".',
-        vm
-      )
-    }
-  }
-}
-
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/
-
-function assertType(
-  value: any,
-  type: Function,
-  vm?: Component
-): {
-  valid: boolean
-  expectedType: string
-} {
-  let valid
-  const expectedType = getType(type)
-  if (simpleCheckRE.test(expectedType)) {
-    const t = typeof value
-    valid = t === expectedType.toLowerCase()
-    // for primitive wrapper objects
-    if (!valid && t === 'object') {
-      valid = value instanceof type
-    }
-  } else if (expectedType === 'Object') {
-    valid = isPlainObject(value)
-  } else if (expectedType === 'Array') {
-    valid = isArray(value)
-  } else {
-    try {
-      valid = value instanceof type
-    } catch (e: any) {
-      warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm)
-      valid = false
-    }
-  }
-  return {
-    valid,
-    expectedType
-  }
-}
-
-const functionTypeCheckRE = /^\s*function (\w+)/
-
-/**
- * Use function string name to check built-in types,
- * because a simple equality check will fail when running
- * across different vms / iframes.
- */
-function getType(fn) {
-  const match = fn && fn.toString().match(functionTypeCheckRE)
-  return match ? match[1] : ''
-}
-
-function isSameType(a, b) {
-  return getType(a) === getType(b)
-}
-
-function getTypeIndex(type, expectedTypes): number {
-  if (!isArray(expectedTypes)) {
-    return isSameType(expectedTypes, type) ? 0 : -1
-  }
-  for (let i = 0, len = expectedTypes.length; i < len; i++) {
-    if (isSameType(expectedTypes[i], type)) {
-      return i
-    }
-  }
-  return -1
-}
-
-function getInvalidTypeMessage(name, value, expectedTypes) {
-  let message =
-    `Invalid prop: type check failed for prop "${name}".` +
-    ` Expected ${expectedTypes.map(capitalize).join(', ')}`
-  const expectedType = expectedTypes[0]
-  const receivedType = toRawType(value)
-  // check if we need to specify expected value
-  if (
-    expectedTypes.length === 1 &&
-    isExplicable(expectedType) &&
-    isExplicable(typeof value) &&
-    !isBoolean(expectedType, receivedType)
-  ) {
-    message += ` with value ${styleValue(value, expectedType)}`
-  }
-  message += `, got ${receivedType} `
-  // check if we need to specify received value
-  if (isExplicable(receivedType)) {
-    message += `with value ${styleValue(value, receivedType)}.`
-  }
-  return message
-}
-
-function styleValue(value, type) {
-  if (type === 'String') {
-    return `"${value}"`
-  } else if (type === 'Number') {
-    return `${Number(value)}`
-  } else {
-    return `${value}`
-  }
-}
-
-const EXPLICABLE_TYPES = ['string', 'number', 'boolean']
-function isExplicable(value) {
-  return EXPLICABLE_TYPES.some(elem => value.toLowerCase() === elem)
-}
-
-function isBoolean(...args) {
-  return args.some(elem => elem.toLowerCase() === 'boolean')
-}

package/vue2/node_modules/vue/src/core/vdom/create-component.ts

@@ -1,275 +0,0 @@
-import VNode from './vnode'
-import { isArray } from 'core/util'
-import { resolveConstructorOptions } from 'core/instance/init'
-import { queueActivatedComponent } from 'core/observer/scheduler'
-import { createFunctionalComponent } from './create-functional-component'
-
-import { warn, isDef, isUndef, isTrue, isObject } from '../util/index'
-
-import {
-  resolveAsyncComponent,
-  createAsyncPlaceholder,
-  extractPropsFromVNodeData
-} from './helpers/index'
-
-import {
-  callHook,
-  activeInstance,
-  updateChildComponent,
-  activateChildComponent,
-  deactivateChildComponent
-} from '../instance/lifecycle'
-
-import type {
-  MountedComponentVNode,
-  VNodeData,
-  VNodeWithData
-} from 'types/vnode'
-import type { Component } from 'types/component'
-import type { ComponentOptions, InternalComponentOptions } from 'types/options'
-
-export function getComponentName(options: ComponentOptions) {
-  return options.name || options.__name || options._componentTag
-}
-
-// inline hooks to be invoked on component VNodes during patch
-const componentVNodeHooks = {
-  init(vnode: VNodeWithData, hydrating: boolean): boolean | void {
-    if (
-      vnode.componentInstance &&
-      !vnode.componentInstance._isDestroyed &&
-      vnode.data.keepAlive
-    ) {
-      // kept-alive components, treat as a patch
-      const mountedNode: any = vnode // work around flow
-      componentVNodeHooks.prepatch(mountedNode, mountedNode)
-    } else {
-      const child = (vnode.componentInstance = createComponentInstanceForVnode(
-        vnode,
-        activeInstance
-      ))
-      child.$mount(hydrating ? vnode.elm : undefined, hydrating)
-    }
-  },
-
-  prepatch(oldVnode: MountedComponentVNode, vnode: MountedComponentVNode) {
-    const options = vnode.componentOptions
-    const child = (vnode.componentInstance = oldVnode.componentInstance)
-    updateChildComponent(
-      child,
-      options.propsData, // updated props
-      options.listeners, // updated listeners
-      vnode, // new parent vnode
-      options.children // new children
-    )
-  },
-
-  insert(vnode: MountedComponentVNode) {
-    const { context, componentInstance } = vnode
-    if (!componentInstance._isMounted) {
-      componentInstance._isMounted = true
-      callHook(componentInstance, 'mounted')
-    }
-    if (vnode.data.keepAlive) {
-      if (context._isMounted) {
-        // vue-router#1212
-        // During updates, a kept-alive component's child components may
-        // change, so directly walking the tree here may call activated hooks
-        // on incorrect children. Instead we push them into a queue which will
-        // be processed after the whole patch process ended.
-        queueActivatedComponent(componentInstance)
-      } else {
-        activateChildComponent(componentInstance, true /* direct */)
-      }
-    }
-  },
-
-  destroy(vnode: MountedComponentVNode) {
-    const { componentInstance } = vnode
-    if (!componentInstance._isDestroyed) {
-      if (!vnode.data.keepAlive) {
-        componentInstance.$destroy()
-      } else {
-        deactivateChildComponent(componentInstance, true /* direct */)
-      }
-    }
-  }
-}
-
-const hooksToMerge = Object.keys(componentVNodeHooks)
-
-export function createComponent(
-  Ctor: typeof Component | Function | ComponentOptions | void,
-  data: VNodeData | undefined,
-  context: Component,
-  children?: Array<VNode>,
-  tag?: string
-): VNode | Array<VNode> | void {
-  if (isUndef(Ctor)) {
-    return
-  }
-
-  const baseCtor = context.$options._base
-
-  // plain options object: turn it into a constructor
-  if (isObject(Ctor)) {
-    Ctor = baseCtor.extend(Ctor as typeof Component)
-  }
-
-  // if at this stage it's not a constructor or an async component factory,
-  // reject.
-  if (typeof Ctor !== 'function') {
-    if (__DEV__) {
-      warn(`Invalid Component definition: ${String(Ctor)}`, context)
-    }
-    return
-  }
-
-  // async component
-  let asyncFactory
-  // @ts-expect-error
-  if (isUndef(Ctor.cid)) {
-    asyncFactory = Ctor
-    Ctor = resolveAsyncComponent(asyncFactory, baseCtor)
-    if (Ctor === undefined) {
-      // return a placeholder node for async component, which is rendered
-      // as a comment node but preserves all the raw information for the node.
-      // the information will be used for async server-rendering and hydration.
-      return createAsyncPlaceholder(asyncFactory, data, context, children, tag)
-    }
-  }
-
-  data = data || {}
-
-  // resolve constructor options in case global mixins are applied after
-  // component constructor creation
-  resolveConstructorOptions(Ctor as typeof Component)
-
-  // transform component v-model data into props & events
-  if (isDef(data.model)) {
-    // @ts-expect-error
-    transformModel(Ctor.options, data)
-  }
-
-  // extract props
-  // @ts-expect-error
-  const propsData = extractPropsFromVNodeData(data, Ctor, tag)
-
-  // functional component
-  // @ts-expect-error
-  if (isTrue(Ctor.options.functional)) {
-    return createFunctionalComponent(
-      Ctor as typeof Component,
-      propsData,
-      data,
-      context,
-      children
-    )
-  }
-
-  // extract listeners, since these needs to be treated as
-  // child component listeners instead of DOM listeners
-  const listeners = data.on
-  // replace with listeners with .native modifier
-  // so it gets processed during parent component patch.
-  data.on = data.nativeOn
-
-  // @ts-expect-error
-  if (isTrue(Ctor.options.abstract)) {
-    // abstract components do not keep anything
-    // other than props & listeners & slot
-
-    // work around flow
-    const slot = data.slot
-    data = {}
-    if (slot) {
-      data.slot = slot
-    }
-  }
-
-  // install component management hooks onto the placeholder node
-  installComponentHooks(data)
-
-  // return a placeholder vnode
-  // @ts-expect-error
-  const name = getComponentName(Ctor.options) || tag
-  const vnode = new VNode(
-    // @ts-expect-error
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`,
-    data,
-    undefined,
-    undefined,
-    undefined,
-    context,
-    // @ts-expect-error
-    { Ctor, propsData, listeners, tag, children },
-    asyncFactory
-  )
-
-  return vnode
-}
-
-export function createComponentInstanceForVnode(
-  // we know it's MountedComponentVNode but flow doesn't
-  vnode: any,
-  // activeInstance in lifecycle state
-  parent?: any
-): Component {
-  const options: InternalComponentOptions = {
-    _isComponent: true,
-    _parentVnode: vnode,
-    parent
-  }
-  // check inline-template render functions
-  const inlineTemplate = vnode.data.inlineTemplate
-  if (isDef(inlineTemplate)) {
-    options.render = inlineTemplate.render
-    options.staticRenderFns = inlineTemplate.staticRenderFns
-  }
-  return new vnode.componentOptions.Ctor(options)
-}
-
-function installComponentHooks(data: VNodeData) {
-  const hooks = data.hook || (data.hook = {})
-  for (let i = 0; i < hooksToMerge.length; i++) {
-    const key = hooksToMerge[i]
-    const existing = hooks[key]
-    const toMerge = componentVNodeHooks[key]
-    // @ts-expect-error
-    if (existing !== toMerge && !(existing && existing._merged)) {
-      hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge
-    }
-  }
-}
-
-function mergeHook(f1: any, f2: any): Function {
-  const merged = (a, b) => {
-    // flow complains about extra args which is why we use any
-    f1(a, b)
-    f2(a, b)
-  }
-  merged._merged = true
-  return merged
-}
-
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel(options, data: any) {
-  const prop = (options.model && options.model.prop) || 'value'
-  const event = (options.model && options.model.event) || 'input'
-  ;(data.attrs || (data.attrs = {}))[prop] = data.model.value
-  const on = data.on || (data.on = {})
-  const existing = on[event]
-  const callback = data.model.callback
-  if (isDef(existing)) {
-    if (
-      isArray(existing)
-        ? existing.indexOf(callback) === -1
-        : existing !== callback
-    ) {
-      on[event] = [callback].concat(existing)
-    }
-  } else {
-    on[event] = callback
-  }
-}

package/vue2/node_modules/vue/src/core/vdom/create-element.ts

@@ -1,172 +0,0 @@
-import config from '../config'
-import VNode, { createEmptyVNode } from './vnode'
-import { createComponent } from './create-component'
-import { traverse } from '../observer/traverse'
-
-import {
-  warn,
-  isDef,
-  isUndef,
-  isArray,
-  isTrue,
-  isObject,
-  isPrimitive,
-  resolveAsset,
-  isFunction
-} from '../util/index'
-
-import { normalizeChildren, simpleNormalizeChildren } from './helpers/index'
-import type { Component } from 'types/component'
-import type { VNodeData } from 'types/vnode'
-
-const SIMPLE_NORMALIZE = 1
-const ALWAYS_NORMALIZE = 2
-
-// wrapper function for providing a more flexible interface
-// without getting yelled at by flow
-export function createElement(
-  context: Component,
-  tag: any,
-  data: any,
-  children: any,
-  normalizationType: any,
-  alwaysNormalize: boolean
-): VNode | Array<VNode> {
-  if (isArray(data) || isPrimitive(data)) {
-    normalizationType = children
-    children = data
-    data = undefined
-  }
-  if (isTrue(alwaysNormalize)) {
-    normalizationType = ALWAYS_NORMALIZE
-  }
-  return _createElement(context, tag, data, children, normalizationType)
-}
-
-export function _createElement(
-  context: Component,
-  tag?: string | Component | Function | Object,
-  data?: VNodeData,
-  children?: any,
-  normalizationType?: number
-): VNode | Array<VNode> {
-  if (isDef(data) && isDef((data as any).__ob__)) {
-    __DEV__ &&
-      warn(
-        `Avoid using observed data object as vnode data: ${JSON.stringify(
-          data
-        )}\n` + 'Always create fresh vnode data objects in each render!',
-        context
-      )
-    return createEmptyVNode()
-  }
-  // object syntax in v-bind
-  if (isDef(data) && isDef(data.is)) {
-    tag = data.is
-  }
-  if (!tag) {
-    // in case of component :is set to falsy value
-    return createEmptyVNode()
-  }
-  // warn against non-primitive key
-  if (__DEV__ && isDef(data) && isDef(data.key) && !isPrimitive(data.key)) {
-    warn(
-      'Avoid using non-primitive value as key, ' +
-        'use string/number value instead.',
-      context
-    )
-  }
-  // support single function children as default scoped slot
-  if (isArray(children) && isFunction(children[0])) {
-    data = data || {}
-    data.scopedSlots = { default: children[0] }
-    children.length = 0
-  }
-  if (normalizationType === ALWAYS_NORMALIZE) {
-    children = normalizeChildren(children)
-  } else if (normalizationType === SIMPLE_NORMALIZE) {
-    children = simpleNormalizeChildren(children)
-  }
-  let vnode, ns
-  if (typeof tag === 'string') {
-    let Ctor
-    ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag)
-    if (config.isReservedTag(tag)) {
-      // platform built-in elements
-      if (
-        __DEV__ &&
-        isDef(data) &&
-        isDef(data.nativeOn) &&
-        data.tag !== 'component'
-      ) {
-        warn(
-          `The .native modifier for v-on is only valid on components but it was used on <${tag}>.`,
-          context
-        )
-      }
-      vnode = new VNode(
-        config.parsePlatformTagName(tag),
-        data,
-        children,
-        undefined,
-        undefined,
-        context
-      )
-    } else if (
-      (!data || !data.pre) &&
-      isDef((Ctor = resolveAsset(context.$options, 'components', tag)))
-    ) {
-      // component
-      vnode = createComponent(Ctor, data, context, children, tag)
-    } else {
-      // unknown or unlisted namespaced elements
-      // check at runtime because it may get assigned a namespace when its
-      // parent normalizes children
-      vnode = new VNode(tag, data, children, undefined, undefined, context)
-    }
-  } else {
-    // direct component options / constructor
-    vnode = createComponent(tag as any, data, context, children)
-  }
-  if (isArray(vnode)) {
-    return vnode
-  } else if (isDef(vnode)) {
-    if (isDef(ns)) applyNS(vnode, ns)
-    if (isDef(data)) registerDeepBindings(data)
-    return vnode
-  } else {
-    return createEmptyVNode()
-  }
-}
-
-function applyNS(vnode, ns, force?: boolean) {
-  vnode.ns = ns
-  if (vnode.tag === 'foreignObject') {
-    // use default namespace inside foreignObject
-    ns = undefined
-    force = true
-  }
-  if (isDef(vnode.children)) {
-    for (let i = 0, l = vnode.children.length; i < l; i++) {
-      const child = vnode.children[i]
-      if (
-        isDef(child.tag) &&
-        (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))
-      ) {
-        applyNS(child, ns, force)
-      }
-    }
-  }
-}
-
-// ref #5318
-// necessary to ensure parent re-render when deep bindings like :style and
-// :class are used on slot nodes
-function registerDeepBindings(data) {
-  if (isObject(data.style)) {
-    traverse(data.style)
-  }
-  if (isObject(data.class)) {
-    traverse(data.class)
-  }
-}