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

package/vue2/node_modules/vue/src/core/instance/render-helpers/render-list.ts

@@ -1,49 +0,0 @@
-import { isObject, isDef, hasSymbol, isArray } from 'core/util/index'
-import VNode from 'core/vdom/vnode'
-
-/**
- * Runtime helper for rendering v-for lists.
- */
-export function renderList(
-  val: any,
-  render: (val: any, keyOrIndex: string | number, index?: number) => VNode
-): Array<VNode> | null {
-  let ret: Array<VNode> | null = null,
-    i,
-    l,
-    keys,
-    key
-  if (isArray(val) || typeof val === 'string') {
-    ret = new Array(val.length)
-    for (i = 0, l = val.length; i < l; i++) {
-      ret[i] = render(val[i], i)
-    }
-  } else if (typeof val === 'number') {
-    ret = new Array(val)
-    for (i = 0; i < val; i++) {
-      ret[i] = render(i + 1, i)
-    }
-  } else if (isObject(val)) {
-    if (hasSymbol && val[Symbol.iterator]) {
-      ret = []
-      const iterator: Iterator<any> = val[Symbol.iterator]()
-      let result = iterator.next()
-      while (!result.done) {
-        ret.push(render(result.value, ret.length))
-        result = iterator.next()
-      }
-    } else {
-      keys = Object.keys(val)
-      ret = new Array(keys.length)
-      for (i = 0, l = keys.length; i < l; i++) {
-        key = keys[i]
-        ret[i] = render(val[key], key, i)
-      }
-    }
-  }
-  if (!isDef(ret)) {
-    ret = []
-  }
-  ;(ret as any)._isVList = true
-  return ret
-}

package/vue2/node_modules/vue/src/core/instance/render-helpers/render-slot.ts

@@ -1,39 +0,0 @@
-import { extend, warn, isObject, isFunction } from 'core/util/index'
-import VNode from 'core/vdom/vnode'
-
-/**
- * Runtime helper for rendering <slot>
- */
-export function renderSlot(
-  name: string,
-  fallbackRender: ((() => Array<VNode>) | Array<VNode>) | null,
-  props: Record<string, any> | null,
-  bindObject: object | null
-): Array<VNode> | null {
-  const scopedSlotFn = this.$scopedSlots[name]
-  let nodes
-  if (scopedSlotFn) {
-    // scoped slot
-    props = props || {}
-    if (bindObject) {
-      if (__DEV__ && !isObject(bindObject)) {
-        warn('slot v-bind without argument expects an Object', this)
-      }
-      props = extend(extend({}, bindObject), props)
-    }
-    nodes =
-      scopedSlotFn(props) ||
-      (isFunction(fallbackRender) ? fallbackRender() : fallbackRender)
-  } else {
-    nodes =
-      this.$slots[name] ||
-      (isFunction(fallbackRender) ? fallbackRender() : fallbackRender)
-  }
-
-  const target = props && props.slot
-  if (target) {
-    return this.$createElement('template', { slot: target }, nodes)
-  } else {
-    return nodes
-  }
-}

package/vue2/node_modules/vue/src/core/instance/render-helpers/render-static.ts

@@ -1,57 +0,0 @@
-import VNode from 'core/vdom/vnode'
-import { isArray } from 'core/util'
-
-/**
- * Runtime helper for rendering static trees.
- */
-export function renderStatic(
-  index: number,
-  isInFor: boolean
-): VNode | Array<VNode> {
-  const cached = this._staticTrees || (this._staticTrees = [])
-  let tree = cached[index]
-  // if has already-rendered static tree and not inside v-for,
-  // we can reuse the same tree.
-  if (tree && !isInFor) {
-    return tree
-  }
-  // otherwise, render a fresh tree.
-  tree = cached[index] = this.$options.staticRenderFns[index].call(
-    this._renderProxy,
-    this._c,
-    this // for render fns generated for functional component templates
-  )
-  markStatic(tree, `__static__${index}`, false)
-  return tree
-}
-
-/**
- * Runtime helper for v-once.
- * Effectively it means marking the node as static with a unique key.
- */
-export function markOnce(
-  tree: VNode | Array<VNode>,
-  index: number,
-  key: string
-) {
-  markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true)
-  return tree
-}
-
-function markStatic(tree: VNode | Array<VNode>, key: string, isOnce: boolean) {
-  if (isArray(tree)) {
-    for (let i = 0; i < tree.length; i++) {
-      if (tree[i] && typeof tree[i] !== 'string') {
-        markStaticNode(tree[i], `${key}_${i}`, isOnce)
-      }
-    }
-  } else {
-    markStaticNode(tree, key, isOnce)
-  }
-}
-
-function markStaticNode(node, key, isOnce) {
-  node.isStatic = true
-  node.key = key
-  node.isOnce = isOnce
-}

package/vue2/node_modules/vue/src/core/instance/render-helpers/resolve-filter.ts

@@ -1,8 +0,0 @@
-import { identity, resolveAsset } from 'core/util/index'
-
-/**
- * Runtime helper for resolving filters
- */
-export function resolveFilter(id: string): Function {
-  return resolveAsset(this.$options, 'filters', id, true) || identity
-}

package/vue2/node_modules/vue/src/core/instance/render-helpers/resolve-scoped-slots.ts

@@ -1,30 +0,0 @@
-import type { ScopedSlotsData } from 'types/vnode'
-import { isArray } from 'core/util'
-
-export function resolveScopedSlots(
-  fns: ScopedSlotsData,
-  res?: Record<string, any>,
-  // the following are added in 2.6
-  hasDynamicKeys?: boolean,
-  contentHashKey?: number
-): { $stable: boolean } & { [key: string]: Function } {
-  res = res || { $stable: !hasDynamicKeys }
-  for (let i = 0; i < fns.length; i++) {
-    const slot = fns[i]
-    if (isArray(slot)) {
-      resolveScopedSlots(slot, res, hasDynamicKeys)
-    } else if (slot) {
-      // marker for reverse proxying v-slot without scope on this.$slots
-      // @ts-expect-error
-      if (slot.proxy) {
-        // @ts-expect-error
-        slot.fn.proxy = true
-      }
-      res[slot.key] = slot.fn
-    }
-  }
-  if (contentHashKey) {
-    ;(res as any).$key = contentHashKey
-  }
-  return res as any
-}

package/vue2/node_modules/vue/src/core/instance/render-helpers/resolve-slots.ts

@@ -1,51 +0,0 @@
-import type VNode from 'core/vdom/vnode'
-import type { Component } from 'types/component'
-
-/**
- * Runtime helper for resolving raw children VNodes into a slot object.
- */
-export function resolveSlots(
-  children: Array<VNode> | null | undefined,
-  context: Component | null
-): { [key: string]: Array<VNode> } {
-  if (!children || !children.length) {
-    return {}
-  }
-  const slots: Record<string, any> = {}
-  for (let i = 0, l = children.length; i < l; i++) {
-    const child = children[i]
-    const data = child.data
-    // remove slot attribute if the node is resolved as a Vue slot node
-    if (data && data.attrs && data.attrs.slot) {
-      delete data.attrs.slot
-    }
-    // named slots should only be respected if the vnode was rendered in the
-    // same context.
-    if (
-      (child.context === context || child.fnContext === context) &&
-      data &&
-      data.slot != null
-    ) {
-      const name = data.slot
-      const slot = slots[name] || (slots[name] = [])
-      if (child.tag === 'template') {
-        slot.push.apply(slot, child.children || [])
-      } else {
-        slot.push(child)
-      }
-    } else {
-      ;(slots.default || (slots.default = [])).push(child)
-    }
-  }
-  // ignore slots that contains only whitespace
-  for (const name in slots) {
-    if (slots[name].every(isWhitespace)) {
-      delete slots[name]
-    }
-  }
-  return slots
-}
-
-function isWhitespace(node: VNode): boolean {
-  return (node.isComment && !node.asyncFactory) || node.text === ' '
-}

package/vue2/node_modules/vue/src/core/instance/render.ts

@@ -1,173 +0,0 @@
-import {
-  warn,
-  nextTick,
-  emptyObject,
-  handleError,
-  defineReactive,
-  isArray
-} from '../util/index'
-
-import { createElement } from '../vdom/create-element'
-import { installRenderHelpers } from './render-helpers/index'
-import { resolveSlots } from './render-helpers/resolve-slots'
-import { normalizeScopedSlots } from '../vdom/helpers/normalize-scoped-slots'
-import VNode, { createEmptyVNode } from '../vdom/vnode'
-
-import { isUpdatingChildComponent } from './lifecycle'
-import type { Component } from 'types/component'
-import { setCurrentInstance } from 'v3/currentInstance'
-import { syncSetupSlots } from 'v3/apiSetup'
-
-export function initRender(vm: Component) {
-  vm._vnode = null // the root of the child tree
-  vm._staticTrees = null // v-once cached trees
-  const options = vm.$options
-  const parentVnode = (vm.$vnode = options._parentVnode!) // the placeholder node in parent tree
-  const renderContext = parentVnode && (parentVnode.context as Component)
-  vm.$slots = resolveSlots(options._renderChildren, renderContext)
-  vm.$scopedSlots = parentVnode
-    ? normalizeScopedSlots(
-        vm.$parent!,
-        parentVnode.data!.scopedSlots,
-        vm.$slots
-      )
-    : emptyObject
-  // bind the createElement fn to this instance
-  // so that we get proper render context inside it.
-  // args order: tag, data, children, normalizationType, alwaysNormalize
-  // internal version is used by render functions compiled from templates
-  // @ts-expect-error
-  vm._c = (a, b, c, d) => createElement(vm, a, b, c, d, false)
-  // normalization is always applied for the public version, used in
-  // user-written render functions.
-  // @ts-expect-error
-  vm.$createElement = (a, b, c, d) => createElement(vm, a, b, c, d, true)
-
-  // $attrs & $listeners are exposed for easier HOC creation.
-  // they need to be reactive so that HOCs using them are always updated
-  const parentData = parentVnode && parentVnode.data
-
-  /* istanbul ignore else */
-  if (__DEV__) {
-    defineReactive(
-      vm,
-      '$attrs',
-      (parentData && parentData.attrs) || emptyObject,
-      () => {
-        !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm)
-      },
-      true
-    )
-    defineReactive(
-      vm,
-      '$listeners',
-      options._parentListeners || emptyObject,
-      () => {
-        !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm)
-      },
-      true
-    )
-  } else {
-    defineReactive(
-      vm,
-      '$attrs',
-      (parentData && parentData.attrs) || emptyObject,
-      null,
-      true
-    )
-    defineReactive(
-      vm,
-      '$listeners',
-      options._parentListeners || emptyObject,
-      null,
-      true
-    )
-  }
-}
-
-export let currentRenderingInstance: Component | null = null
-
-// for testing only
-export function setCurrentRenderingInstance(vm: Component) {
-  currentRenderingInstance = vm
-}
-
-export function renderMixin(Vue: typeof Component) {
-  // install runtime convenience helpers
-  installRenderHelpers(Vue.prototype)
-
-  Vue.prototype.$nextTick = function (fn: (...args: any[]) => any) {
-    return nextTick(fn, this)
-  }
-
-  Vue.prototype._render = function (): VNode {
-    const vm: Component = this
-    const { render, _parentVnode } = vm.$options
-
-    if (_parentVnode && vm._isMounted) {
-      vm.$scopedSlots = normalizeScopedSlots(
-        vm.$parent!,
-        _parentVnode.data!.scopedSlots,
-        vm.$slots,
-        vm.$scopedSlots
-      )
-      if (vm._slotsProxy) {
-        syncSetupSlots(vm._slotsProxy, vm.$scopedSlots)
-      }
-    }
-
-    // set parent vnode. this allows render functions to have access
-    // to the data on the placeholder node.
-    vm.$vnode = _parentVnode!
-    // render self
-    let vnode
-    try {
-      // There's no need to maintain a stack because all render fns are called
-      // separately from one another. Nested component's render fns are called
-      // when parent component is patched.
-      setCurrentInstance(vm)
-      currentRenderingInstance = vm
-      vnode = render.call(vm._renderProxy, vm.$createElement)
-    } catch (e: any) {
-      handleError(e, vm, `render`)
-      // return error render result,
-      // or previous vnode to prevent render error causing blank component
-      /* istanbul ignore else */
-      if (__DEV__ && vm.$options.renderError) {
-        try {
-          vnode = vm.$options.renderError.call(
-            vm._renderProxy,
-            vm.$createElement,
-            e
-          )
-        } catch (e: any) {
-          handleError(e, vm, `renderError`)
-          vnode = vm._vnode
-        }
-      } else {
-        vnode = vm._vnode
-      }
-    } finally {
-      currentRenderingInstance = null
-      setCurrentInstance()
-    }
-    // if the returned array contains only a single node, allow it
-    if (isArray(vnode) && vnode.length === 1) {
-      vnode = vnode[0]
-    }
-    // return empty vnode in case the render function errored out
-    if (!(vnode instanceof VNode)) {
-      if (__DEV__ && isArray(vnode)) {
-        warn(
-          'Multiple root nodes returned from render function. Render function ' +
-            'should return a single root node.',
-          vm
-        )
-      }
-      vnode = createEmptyVNode()
-    }
-    // set parent
-    vnode.parent = _parentVnode
-    return vnode
-  }
-}