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

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

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

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

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

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

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

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

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