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

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

@@ -1,180 +0,0 @@
-import VNode, { cloneVNode } from './vnode'
-import { createElement } from './create-element'
-import { resolveInject } from '../instance/inject'
-import { normalizeChildren } from '../vdom/helpers/normalize-children'
-import { resolveSlots } from '../instance/render-helpers/resolve-slots'
-import { normalizeScopedSlots } from '../vdom/helpers/normalize-scoped-slots'
-import { installRenderHelpers } from '../instance/render-helpers/index'
-
-import {
-  isDef,
-  isTrue,
-  hasOwn,
-  isArray,
-  camelize,
-  emptyObject,
-  validateProp
-} from '../util/index'
-import type { Component } from 'types/component'
-import type { VNodeData } from 'types/vnode'
-
-export function FunctionalRenderContext(
-  data: VNodeData,
-  props: Object,
-  children: Array<VNode> | undefined,
-  parent: Component,
-  Ctor: typeof Component
-) {
-  const options = Ctor.options
-  // ensure the createElement function in functional components
-  // gets a unique context - this is necessary for correct named slot check
-  let contextVm
-  if (hasOwn(parent, '_uid')) {
-    contextVm = Object.create(parent)
-    contextVm._original = parent
-  } else {
-    // the context vm passed in is a functional context as well.
-    // in this case we want to make sure we are able to get a hold to the
-    // real context instance.
-    contextVm = parent
-    // @ts-ignore
-    parent = parent._original
-  }
-  const isCompiled = isTrue(options._compiled)
-  const needNormalization = !isCompiled
-
-  this.data = data
-  this.props = props
-  this.children = children
-  this.parent = parent
-  this.listeners = data.on || emptyObject
-  this.injections = resolveInject(options.inject, parent)
-  this.slots = () => {
-    if (!this.$slots) {
-      normalizeScopedSlots(
-        parent,
-        data.scopedSlots,
-        (this.$slots = resolveSlots(children, parent))
-      )
-    }
-    return this.$slots
-  }
-
-  Object.defineProperty(this, 'scopedSlots', {
-    enumerable: true,
-    get() {
-      return normalizeScopedSlots(parent, data.scopedSlots, this.slots())
-    }
-  } as any)
-
-  // support for compiled functional template
-  if (isCompiled) {
-    // exposing $options for renderStatic()
-    this.$options = options
-    // pre-resolve slots for renderSlot()
-    this.$slots = this.slots()
-    this.$scopedSlots = normalizeScopedSlots(
-      parent,
-      data.scopedSlots,
-      this.$slots
-    )
-  }
-
-  if (options._scopeId) {
-    this._c = (a, b, c, d) => {
-      const vnode = createElement(contextVm, a, b, c, d, needNormalization)
-      if (vnode && !isArray(vnode)) {
-        vnode.fnScopeId = options._scopeId
-        vnode.fnContext = parent
-      }
-      return vnode
-    }
-  } else {
-    this._c = (a, b, c, d) =>
-      createElement(contextVm, a, b, c, d, needNormalization)
-  }
-}
-
-installRenderHelpers(FunctionalRenderContext.prototype)
-
-export function createFunctionalComponent(
-  Ctor: typeof Component,
-  propsData: Object | undefined,
-  data: VNodeData,
-  contextVm: Component,
-  children?: Array<VNode>
-): VNode | Array<VNode> | void {
-  const options = Ctor.options
-  const props = {}
-  const propOptions = options.props
-  if (isDef(propOptions)) {
-    for (const key in propOptions) {
-      props[key] = validateProp(key, propOptions, propsData || emptyObject)
-    }
-  } else {
-    if (isDef(data.attrs)) mergeProps(props, data.attrs)
-    if (isDef(data.props)) mergeProps(props, data.props)
-  }
-
-  const renderContext = new FunctionalRenderContext(
-    data,
-    props,
-    children,
-    contextVm,
-    Ctor
-  )
-
-  const vnode = options.render.call(null, renderContext._c, renderContext)
-
-  if (vnode instanceof VNode) {
-    return cloneAndMarkFunctionalResult(
-      vnode,
-      data,
-      renderContext.parent,
-      options,
-      renderContext
-    )
-  } else if (isArray(vnode)) {
-    const vnodes = normalizeChildren(vnode) || []
-    const res = new Array(vnodes.length)
-    for (let i = 0; i < vnodes.length; i++) {
-      res[i] = cloneAndMarkFunctionalResult(
-        vnodes[i],
-        data,
-        renderContext.parent,
-        options,
-        renderContext
-      )
-    }
-    return res
-  }
-}
-
-function cloneAndMarkFunctionalResult(
-  vnode,
-  data,
-  contextVm,
-  options,
-  renderContext
-) {
-  // #7817 clone node before setting fnContext, otherwise if the node is reused
-  // (e.g. it was from a cached normal slot) the fnContext causes named slots
-  // that should not be matched to match.
-  const clone = cloneVNode(vnode)
-  clone.fnContext = contextVm
-  clone.fnOptions = options
-  if (__DEV__) {
-    ;(clone.devtoolsMeta = clone.devtoolsMeta || ({} as any)).renderContext =
-      renderContext
-  }
-  if (data.slot) {
-    ;(clone.data || (clone.data = {})).slot = data.slot
-  }
-  return clone
-}
-
-function mergeProps(to, from) {
-  for (const key in from) {
-    to[camelize(key)] = from[key]
-  }
-}

package/vue2/node_modules/vue/src/core/vdom/helpers/extract-props.ts

@@ -1,75 +0,0 @@
-import {
-  tip,
-  hasOwn,
-  isDef,
-  isUndef,
-  hyphenate,
-  formatComponentName
-} from 'core/util/index'
-import type { Component } from 'types/component'
-import type { VNodeData } from 'types/vnode'
-
-export function extractPropsFromVNodeData(
-  data: VNodeData,
-  Ctor: typeof Component,
-  tag?: string
-): object | undefined {
-  // we are only extracting raw values here.
-  // validation and default values are handled in the child
-  // component itself.
-  const propOptions = Ctor.options.props
-  if (isUndef(propOptions)) {
-    return
-  }
-  const res = {}
-  const { attrs, props } = data
-  if (isDef(attrs) || isDef(props)) {
-    for (const key in propOptions) {
-      const altKey = hyphenate(key)
-      if (__DEV__) {
-        const keyInLowerCase = key.toLowerCase()
-        if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-          tip(
-            `Prop "${keyInLowerCase}" is passed to component ` +
-              `${formatComponentName(
-                // @ts-expect-error tag is string
-                tag || Ctor
-              )}, but the declared prop name is` +
-              ` "${key}". ` +
-              `Note that HTML attributes are case-insensitive and camelCased ` +
-              `props need to use their kebab-case equivalents when using in-DOM ` +
-              `templates. You should probably use "${altKey}" instead of "${key}".`
-          )
-        }
-      }
-      checkProp(res, props, key, altKey, true) ||
-        checkProp(res, attrs, key, altKey, false)
-    }
-  }
-  return res
-}
-
-function checkProp(
-  res: Object,
-  hash: Object | undefined,
-  key: string,
-  altKey: string,
-  preserve: boolean
-): boolean {
-  if (isDef(hash)) {
-    if (hasOwn(hash, key)) {
-      res[key] = hash[key]
-      if (!preserve) {
-        delete hash[key]
-      }
-      return true
-    } else if (hasOwn(hash, altKey)) {
-      res[key] = hash[altKey]
-      if (!preserve) {
-        delete hash[altKey]
-      }
-      return true
-    }
-  }
-  return false
-}

package/vue2/node_modules/vue/src/core/vdom/helpers/get-first-component-child.ts

@@ -1,16 +0,0 @@
-import { isDef, isArray } from 'shared/util'
-import VNode from '../vnode'
-import { isAsyncPlaceholder } from './is-async-placeholder'
-
-export function getFirstComponentChild(
-  children?: Array<VNode>
-): VNode | undefined {
-  if (isArray(children)) {
-    for (let i = 0; i < children.length; i++) {
-      const c = children[i]
-      if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-        return c
-      }
-    }
-  }
-}

package/vue2/node_modules/vue/src/core/vdom/helpers/index.ts

@@ -1,7 +0,0 @@
-export * from './merge-hook'
-export * from './extract-props'
-export * from './update-listeners'
-export * from './normalize-children'
-export * from './resolve-async-component'
-export * from './get-first-component-child'
-export * from './is-async-placeholder'

package/vue2/node_modules/vue/src/core/vdom/helpers/is-async-placeholder.ts

@@ -1,6 +0,0 @@
-import VNode from '../vnode'
-
-export function isAsyncPlaceholder(node: VNode): boolean {
-  // @ts-expect-error not really boolean type
-  return node.isComment && node.asyncFactory
-}

package/vue2/node_modules/vue/src/core/vdom/helpers/merge-hook.ts

@@ -1,40 +0,0 @@
-import VNode from '../vnode'
-import { createFnInvoker } from './update-listeners'
-import { remove, isDef, isUndef, isTrue } from 'shared/util'
-
-export function mergeVNodeHook(
-  def: Record<string, any>,
-  hookKey: string,
-  hook: Function
-) {
-  if (def instanceof VNode) {
-    def = def.data!.hook || (def.data!.hook = {})
-  }
-  let invoker
-  const oldHook = def[hookKey]
-
-  function wrappedHook() {
-    hook.apply(this, arguments)
-    // important: remove merged hook to ensure it's called only once
-    // and prevent memory leak
-    remove(invoker.fns, wrappedHook)
-  }
-
-  if (isUndef(oldHook)) {
-    // no existing hook
-    invoker = createFnInvoker([wrappedHook])
-  } else {
-    /* istanbul ignore if */
-    if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-      // already a merged invoker
-      invoker = oldHook
-      invoker.fns.push(wrappedHook)
-    } else {
-      // existing plain hook
-      invoker = createFnInvoker([oldHook, wrappedHook])
-    }
-  }
-
-  invoker.merged = true
-  def[hookKey] = invoker
-}

package/vue2/node_modules/vue/src/core/vdom/helpers/normalize-children.ts

@@ -1,99 +0,0 @@
-import VNode, { createTextVNode } from 'core/vdom/vnode'
-import {
-  isFalse,
-  isTrue,
-  isArray,
-  isDef,
-  isUndef,
-  isPrimitive
-} from 'shared/util'
-
-// The template compiler attempts to minimize the need for normalization by
-// statically analyzing the template at compile time.
-//
-// For plain HTML markup, normalization can be completely skipped because the
-// generated render function is guaranteed to return Array<VNode>. There are
-// two cases where extra normalization is needed:
-
-// 1. When the children contains components - because a functional component
-// may return an Array instead of a single root. In this case, just a simple
-// normalization is needed - if any child is an Array, we flatten the whole
-// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-// because functional components already normalize their own children.
-export function simpleNormalizeChildren(children: any) {
-  for (let i = 0; i < children.length; i++) {
-    if (isArray(children[i])) {
-      return Array.prototype.concat.apply([], children)
-    }
-  }
-  return children
-}
-
-// 2. When the children contains constructs that always generated nested Arrays,
-// e.g. <template>, <slot>, v-for, or when the children is provided by user
-// with hand-written render functions / JSX. In such cases a full normalization
-// is needed to cater to all possible types of children values.
-export function normalizeChildren(children: any): Array<VNode> | undefined {
-  return isPrimitive(children)
-    ? [createTextVNode(children)]
-    : isArray(children)
-    ? normalizeArrayChildren(children)
-    : undefined
-}
-
-function isTextNode(node): boolean {
-  return isDef(node) && isDef(node.text) && isFalse(node.isComment)
-}
-
-function normalizeArrayChildren(
-  children: any,
-  nestedIndex?: string
-): Array<VNode> {
-  const res: VNode[] = []
-  let i, c, lastIndex, last
-  for (i = 0; i < children.length; i++) {
-    c = children[i]
-    if (isUndef(c) || typeof c === 'boolean') continue
-    lastIndex = res.length - 1
-    last = res[lastIndex]
-    //  nested
-    if (isArray(c)) {
-      if (c.length > 0) {
-        c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`)
-        // merge adjacent text nodes
-        if (isTextNode(c[0]) && isTextNode(last)) {
-          res[lastIndex] = createTextVNode(last.text + c[0].text)
-          c.shift()
-        }
-        res.push.apply(res, c)
-      }
-    } else if (isPrimitive(c)) {
-      if (isTextNode(last)) {
-        // merge adjacent text nodes
-        // this is necessary for SSR hydration because text nodes are
-        // essentially merged when rendered to HTML strings
-        res[lastIndex] = createTextVNode(last.text + c)
-      } else if (c !== '') {
-        // convert primitive to vnode
-        res.push(createTextVNode(c))
-      }
-    } else {
-      if (isTextNode(c) && isTextNode(last)) {
-        // merge adjacent text nodes
-        res[lastIndex] = createTextVNode(last.text + c.text)
-      } else {
-        // default key for nested array children (likely generated by v-for)
-        if (
-          isTrue(children._isVList) &&
-          isDef(c.tag) &&
-          isUndef(c.key) &&
-          isDef(nestedIndex)
-        ) {
-          c.key = `__vlist${nestedIndex}_${i}__`
-        }
-        res.push(c)
-      }
-    }
-  }
-  return res
-}

package/vue2/node_modules/vue/src/core/vdom/helpers/normalize-scoped-slots.ts

@@ -1,97 +0,0 @@
-import { def } from 'core/util/lang'
-import { normalizeChildren } from 'core/vdom/helpers/normalize-children'
-import { emptyObject, isArray } from 'shared/util'
-import { isAsyncPlaceholder } from './is-async-placeholder'
-import type VNode from '../vnode'
-import { Component } from 'types/component'
-import { currentInstance, setCurrentInstance } from 'v3/currentInstance'
-
-export function normalizeScopedSlots(
-  ownerVm: Component,
-  scopedSlots: { [key: string]: Function } | undefined,
-  normalSlots: { [key: string]: VNode[] },
-  prevScopedSlots?: { [key: string]: Function }
-): any {
-  let res
-  const hasNormalSlots = Object.keys(normalSlots).length > 0
-  const isStable = scopedSlots ? !!scopedSlots.$stable : !hasNormalSlots
-  const key = scopedSlots && scopedSlots.$key
-  if (!scopedSlots) {
-    res = {}
-  } else if (scopedSlots._normalized) {
-    // fast path 1: child component re-render only, parent did not change
-    return scopedSlots._normalized
-  } else if (
-    isStable &&
-    prevScopedSlots &&
-    prevScopedSlots !== emptyObject &&
-    key === prevScopedSlots.$key &&
-    !hasNormalSlots &&
-    !prevScopedSlots.$hasNormal
-  ) {
-    // fast path 2: stable scoped slots w/ no normal slots to proxy,
-    // only need to normalize once
-    return prevScopedSlots
-  } else {
-    res = {}
-    for (const key in scopedSlots) {
-      if (scopedSlots[key] && key[0] !== '$') {
-        res[key] = normalizeScopedSlot(
-          ownerVm,
-          normalSlots,
-          key,
-          scopedSlots[key]
-        )
-      }
-    }
-  }
-  // expose normal slots on scopedSlots
-  for (const key in normalSlots) {
-    if (!(key in res)) {
-      res[key] = proxyNormalSlot(normalSlots, key)
-    }
-  }
-  // avoriaz seems to mock a non-extensible $scopedSlots object
-  // and when that is passed down this would cause an error
-  if (scopedSlots && Object.isExtensible(scopedSlots)) {
-    scopedSlots._normalized = res
-  }
-  def(res, '$stable', isStable)
-  def(res, '$key', key)
-  def(res, '$hasNormal', hasNormalSlots)
-  return res
-}
-
-function normalizeScopedSlot(vm, normalSlots, key, fn) {
-  const normalized = function () {
-    const cur = currentInstance
-    setCurrentInstance(vm)
-    let res = arguments.length ? fn.apply(null, arguments) : fn({})
-    res =
-      res && typeof res === 'object' && !isArray(res)
-        ? [res] // single vnode
-        : normalizeChildren(res)
-    const vnode: VNode | null = res && res[0]
-    setCurrentInstance(cur)
-    return res &&
-      (!vnode ||
-        (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-      ? undefined
-      : res
-  }
-  // this is a slot using the new v-slot syntax without scope. although it is
-  // compiled as a scoped slot, render fn users would expect it to be present
-  // on this.$slots because the usage is semantically a normal slot.
-  if (fn.proxy) {
-    Object.defineProperty(normalSlots, key, {
-      get: normalized,
-      enumerable: true,
-      configurable: true
-    })
-  }
-  return normalized
-}
-
-function proxyNormalSlot(slots, key) {
-  return () => slots[key]
-}

package/vue2/node_modules/vue/src/core/vdom/helpers/resolve-async-component.ts

@@ -1,157 +0,0 @@
-import {
-  warn,
-  once,
-  isDef,
-  isUndef,
-  isTrue,
-  isObject,
-  hasSymbol,
-  isPromise,
-  remove
-} from 'core/util/index'
-
-import VNode, { createEmptyVNode } from 'core/vdom/vnode'
-import { currentRenderingInstance } from 'core/instance/render'
-import type { VNodeData } from 'types/vnode'
-import type { Component } from 'types/component'
-
-function ensureCtor(comp: any, base) {
-  if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-    comp = comp.default
-  }
-  return isObject(comp) ? base.extend(comp) : comp
-}
-
-export function createAsyncPlaceholder(
-  factory: Function,
-  data: VNodeData | undefined,
-  context: Component,
-  children: Array<VNode> | undefined,
-  tag?: string
-): VNode {
-  const node = createEmptyVNode()
-  node.asyncFactory = factory
-  node.asyncMeta = { data, context, children, tag }
-  return node
-}
-
-export function resolveAsyncComponent(
-  factory: { (...args: any[]): any; [keye: string]: any },
-  baseCtor: typeof Component
-): typeof Component | void {
-  if (isTrue(factory.error) && isDef(factory.errorComp)) {
-    return factory.errorComp
-  }
-
-  if (isDef(factory.resolved)) {
-    return factory.resolved
-  }
-
-  const owner = currentRenderingInstance
-  if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-    // already pending
-    factory.owners.push(owner)
-  }
-
-  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-    return factory.loadingComp
-  }
-
-  if (owner && !isDef(factory.owners)) {
-    const owners = (factory.owners = [owner])
-    let sync = true
-    let timerLoading: number | null = null
-    let timerTimeout: number | null = null
-
-    owner.$on('hook:destroyed', () => remove(owners, owner))
-
-    const forceRender = (renderCompleted: boolean) => {
-      for (let i = 0, l = owners.length; i < l; i++) {
-        owners[i].$forceUpdate()
-      }
-
-      if (renderCompleted) {
-        owners.length = 0
-        if (timerLoading !== null) {
-          clearTimeout(timerLoading)
-          timerLoading = null
-        }
-        if (timerTimeout !== null) {
-          clearTimeout(timerTimeout)
-          timerTimeout = null
-        }
-      }
-    }
-
-    const resolve = once((res: Object | Component) => {
-      // cache resolved
-      factory.resolved = ensureCtor(res, baseCtor)
-      // invoke callbacks only if this is not a synchronous resolve
-      // (async resolves are shimmed as synchronous during SSR)
-      if (!sync) {
-        forceRender(true)
-      } else {
-        owners.length = 0
-      }
-    })
-
-    const reject = once(reason => {
-      __DEV__ &&
-        warn(
-          `Failed to resolve async component: ${String(factory)}` +
-            (reason ? `\nReason: ${reason}` : '')
-        )
-      if (isDef(factory.errorComp)) {
-        factory.error = true
-        forceRender(true)
-      }
-    })
-
-    const res = factory(resolve, reject)
-
-    if (isObject(res)) {
-      if (isPromise(res)) {
-        // () => Promise
-        if (isUndef(factory.resolved)) {
-          res.then(resolve, reject)
-        }
-      } else if (isPromise(res.component)) {
-        res.component.then(resolve, reject)
-
-        if (isDef(res.error)) {
-          factory.errorComp = ensureCtor(res.error, baseCtor)
-        }
-
-        if (isDef(res.loading)) {
-          factory.loadingComp = ensureCtor(res.loading, baseCtor)
-          if (res.delay === 0) {
-            factory.loading = true
-          } else {
-            // @ts-expect-error NodeJS timeout type
-            timerLoading = setTimeout(() => {
-              timerLoading = null
-              if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                factory.loading = true
-                forceRender(false)
-              }
-            }, res.delay || 200)
-          }
-        }
-
-        if (isDef(res.timeout)) {
-          // @ts-expect-error NodeJS timeout type
-          timerTimeout = setTimeout(() => {
-            timerTimeout = null
-            if (isUndef(factory.resolved)) {
-              reject(__DEV__ ? `timeout (${res.timeout}ms)` : null)
-            }
-          }, res.timeout)
-        }
-      }
-    }
-
-    sync = false
-    // return in case resolved synchronously
-    return factory.loading ? factory.loadingComp : factory.resolved
-  }
-}