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

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

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

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

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

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

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

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

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

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

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