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

package/vue2/node_modules/vue/src/core/vdom/vnode.ts

@@ -0,0 +1,119 @@
+import type { Component } from 'types/component'
+import type { ComponentOptions } from 'types/options'
+import type { VNodeComponentOptions, VNodeData } from 'types/vnode'
+
+/**
+ * @internal
+ */
+export default class VNode {
+  tag?: string
+  data: VNodeData | undefined
+  children?: Array<VNode> | null
+  text?: string
+  elm: Node | undefined
+  ns?: string
+  context?: Component // rendered in this component's scope
+  key: string | number | undefined
+  componentOptions?: VNodeComponentOptions
+  componentInstance?: Component // component instance
+  parent: VNode | undefined | null // component placeholder node
+
+  // strictly internal
+  raw: boolean // contains raw HTML? (server only)
+  isStatic: boolean // hoisted static node
+  isRootInsert: boolean // necessary for enter transition check
+  isComment: boolean // empty comment placeholder?
+  isCloned: boolean // is a cloned node?
+  isOnce: boolean // is a v-once node?
+  asyncFactory?: Function // async component factory function
+  asyncMeta: Object | void
+  isAsyncPlaceholder: boolean
+  ssrContext?: Object | void
+  fnContext: Component | void // real context vm for functional nodes
+  fnOptions?: ComponentOptions | null // for SSR caching
+  devtoolsMeta?: Object | null // used to store functional render context for devtools
+  fnScopeId?: string | null // functional scope id support
+  isComponentRootElement?: boolean | null // for SSR directives
+
+  constructor(
+    tag?: string,
+    data?: VNodeData,
+    children?: Array<VNode> | null,
+    text?: string,
+    elm?: Node,
+    context?: Component,
+    componentOptions?: VNodeComponentOptions,
+    asyncFactory?: Function
+  ) {
+    this.tag = tag
+    this.data = data
+    this.children = children
+    this.text = text
+    this.elm = elm
+    this.ns = undefined
+    this.context = context
+    this.fnContext = undefined
+    this.fnOptions = undefined
+    this.fnScopeId = undefined
+    this.key = data && data.key
+    this.componentOptions = componentOptions
+    this.componentInstance = undefined
+    this.parent = undefined
+    this.raw = false
+    this.isStatic = false
+    this.isRootInsert = true
+    this.isComment = false
+    this.isCloned = false
+    this.isOnce = false
+    this.asyncFactory = asyncFactory
+    this.asyncMeta = undefined
+    this.isAsyncPlaceholder = false
+  }
+
+  // DEPRECATED: alias for componentInstance for backwards compat.
+  /* istanbul ignore next */
+  get child(): Component | void {
+    return this.componentInstance
+  }
+}
+
+export const createEmptyVNode = (text: string = '') => {
+  const node = new VNode()
+  node.text = text
+  node.isComment = true
+  return node
+}
+
+export function createTextVNode(val: string | number) {
+  return new VNode(undefined, undefined, undefined, String(val))
+}
+
+// optimized shallow clone
+// used for static nodes and slot nodes because they may be reused across
+// multiple renders, cloning them avoids errors when DOM manipulations rely
+// on their elm reference.
+export function cloneVNode(vnode: VNode): VNode {
+  const cloned = new VNode(
+    vnode.tag,
+    vnode.data,
+    // #7975
+    // clone children array to avoid mutating original in case of cloning
+    // a child.
+    vnode.children && vnode.children.slice(),
+    vnode.text,
+    vnode.elm,
+    vnode.context,
+    vnode.componentOptions,
+    vnode.asyncFactory
+  )
+  cloned.ns = vnode.ns
+  cloned.isStatic = vnode.isStatic
+  cloned.key = vnode.key
+  cloned.isComment = vnode.isComment
+  cloned.fnContext = vnode.fnContext
+  cloned.fnOptions = vnode.fnOptions
+  cloned.fnScopeId = vnode.fnScopeId
+  cloned.asyncMeta = vnode.asyncMeta
+  cloned.isCloned = true
+  return cloned
+}

package/vue2/node_modules/vue/src/global.d.ts

@@ -0,0 +1,17 @@
+declare const __DEV__: boolean
+declare const __TEST__: boolean
+declare const __GLOBAL__: boolean
+
+interface Window {
+  __VUE_DEVTOOLS_GLOBAL_HOOK__: DevtoolsHook
+}
+
+// from https://github.com/vuejs/vue-devtools/blob/bc719c95a744614f5c3693460b64dc21dfa339a8/packages/app-backend-api/src/global-hook.ts#L3
+interface DevtoolsHook {
+  emit: (event: string, ...payload: any[]) => void
+  on: (event: string, handler: Function) => void
+  once: (event: string, handler: Function) => void
+  off: (event?: string, handler?: Function) => void
+  Vue?: any
+  // apps: AppRecordOptions[]
+}

package/vue2/node_modules/vue/src/platforms/web/compiler/directives/html.ts

@@ -0,0 +1,8 @@
+import { addProp } from 'compiler/helpers'
+import { ASTDirective, ASTElement } from 'types/compiler'
+
+export default function html(el: ASTElement, dir: ASTDirective) {
+  if (dir.value) {
+    addProp(el, 'innerHTML', `_s(${dir.value})`, dir)
+  }
+}

package/vue2/node_modules/vue/src/platforms/web/compiler/directives/index.ts

@@ -0,0 +1,9 @@
+import model from './model'
+import text from './text'
+import html from './html'
+
+export default {
+  model,
+  text,
+  html
+}

package/vue2/node_modules/vue/src/platforms/web/compiler/directives/model.ts

@@ -0,0 +1,181 @@
+import config from 'core/config'
+import { addHandler, addProp, getBindingAttr } from 'compiler/helpers'
+import { genComponentModel, genAssignmentCode } from 'compiler/directives/model'
+import { ASTDirective, ASTElement, ASTModifiers } from 'types/compiler'
+
+let warn
+
+// in some cases, the event used has to be determined at runtime
+// so we used some reserved tokens during compile.
+export const RANGE_TOKEN = '__r'
+export const CHECKBOX_RADIO_TOKEN = '__c'
+
+export default function model(
+  el: ASTElement,
+  dir: ASTDirective,
+  _warn: Function
+): boolean | undefined {
+  warn = _warn
+  const value = dir.value
+  const modifiers = dir.modifiers
+  const tag = el.tag
+  const type = el.attrsMap.type
+
+  if (__DEV__) {
+    // inputs with type="file" are read only and setting the input's
+    // value will throw an error.
+    if (tag === 'input' && type === 'file') {
+      warn(
+        `<${el.tag} v-model="${value}" type="file">:\n` +
+          `File inputs are read only. Use a v-on:change listener instead.`,
+        el.rawAttrsMap['v-model']
+      )
+    }
+  }
+
+  if (el.component) {
+    genComponentModel(el, value, modifiers)
+    // component v-model doesn't need extra runtime
+    return false
+  } else if (tag === 'select') {
+    genSelect(el, value, modifiers)
+  } else if (tag === 'input' && type === 'checkbox') {
+    genCheckboxModel(el, value, modifiers)
+  } else if (tag === 'input' && type === 'radio') {
+    genRadioModel(el, value, modifiers)
+  } else if (tag === 'input' || tag === 'textarea') {
+    genDefaultModel(el, value, modifiers)
+  } else if (!config.isReservedTag(tag)) {
+    genComponentModel(el, value, modifiers)
+    // component v-model doesn't need extra runtime
+    return false
+  } else if (__DEV__) {
+    warn(
+      `<${el.tag} v-model="${value}">: ` +
+        `v-model is not supported on this element type. ` +
+        "If you are working with contenteditable, it's recommended to " +
+        'wrap a library dedicated for that purpose inside a custom component.',
+      el.rawAttrsMap['v-model']
+    )
+  }
+
+  // ensure runtime directive metadata
+  return true
+}
+
+function genCheckboxModel(
+  el: ASTElement,
+  value: string,
+  modifiers?: ASTModifiers | null
+) {
+  const number = modifiers && modifiers.number
+  const valueBinding = getBindingAttr(el, 'value') || 'null'
+  const trueValueBinding = getBindingAttr(el, 'true-value') || 'true'
+  const falseValueBinding = getBindingAttr(el, 'false-value') || 'false'
+  addProp(
+    el,
+    'checked',
+    `Array.isArray(${value})` +
+      `?_i(${value},${valueBinding})>-1` +
+      (trueValueBinding === 'true'
+        ? `:(${value})`
+        : `:_q(${value},${trueValueBinding})`)
+  )
+  addHandler(
+    el,
+    'change',
+    `var $$a=${value},` +
+      '$$el=$event.target,' +
+      `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+      'if(Array.isArray($$a)){' +
+      `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+      '$$i=_i($$a,$$v);' +
+      `if($$el.checked){$$i<0&&(${genAssignmentCode(
+        value,
+        '$$a.concat([$$v])'
+      )})}` +
+      `else{$$i>-1&&(${genAssignmentCode(
+        value,
+        '$$a.slice(0,$$i).concat($$a.slice($$i+1))'
+      )})}` +
+      `}else{${genAssignmentCode(value, '$$c')}}`,
+    null,
+    true
+  )
+}
+
+function genRadioModel(
+  el: ASTElement,
+  value: string,
+  modifiers?: ASTModifiers | null
+) {
+  const number = modifiers && modifiers.number
+  let valueBinding = getBindingAttr(el, 'value') || 'null'
+  valueBinding = number ? `_n(${valueBinding})` : valueBinding
+  addProp(el, 'checked', `_q(${value},${valueBinding})`)
+  addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true)
+}
+
+function genSelect(
+  el: ASTElement,
+  value: string,
+  modifiers?: ASTModifiers | null
+) {
+  const number = modifiers && modifiers.number
+  const selectedVal =
+    `Array.prototype.filter` +
+    `.call($event.target.options,function(o){return o.selected})` +
+    `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+    `return ${number ? '_n(val)' : 'val'}})`
+
+  const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]'
+  let code = `var $$selectedVal = ${selectedVal};`
+  code = `${code} ${genAssignmentCode(value, assignment)}`
+  addHandler(el, 'change', code, null, true)
+}
+
+function genDefaultModel(
+  el: ASTElement,
+  value: string,
+  modifiers?: ASTModifiers | null
+): boolean | void {
+  const type = el.attrsMap.type
+
+  // warn if v-bind:value conflicts with v-model
+  // except for inputs with v-bind:type
+  if (__DEV__) {
+    const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value']
+    const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type']
+    if (value && !typeBinding) {
+      const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value'
+      warn(
+        `${binding}="${value}" conflicts with v-model on the same element ` +
+          'because the latter already expands to a value binding internally',
+        el.rawAttrsMap[binding]
+      )
+    }
+  }
+
+  const { lazy, number, trim } = modifiers || {}
+  const needCompositionGuard = !lazy && type !== 'range'
+  const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input'
+
+  let valueExpression = '$event.target.value'
+  if (trim) {
+    valueExpression = `$event.target.value.trim()`
+  }
+  if (number) {
+    valueExpression = `_n(${valueExpression})`
+  }
+
+  let code = genAssignmentCode(value, valueExpression)
+  if (needCompositionGuard) {
+    code = `if($event.target.composing)return;${code}`
+  }
+
+  addProp(el, 'value', `(${value})`)
+  addHandler(el, event, code, null, true)
+  if (trim || number) {
+    addHandler(el, 'blur', '$forceUpdate()')
+  }
+}

package/vue2/node_modules/vue/src/platforms/web/compiler/directives/text.ts

@@ -0,0 +1,8 @@
+import { addProp } from 'compiler/helpers'
+import { ASTDirective, ASTElement } from 'types/compiler'
+
+export default function text(el: ASTElement, dir: ASTDirective) {
+  if (dir.value) {
+    addProp(el, 'textContent', `_s(${dir.value})`, dir)
+  }
+}

package/vue2/node_modules/vue/src/platforms/web/compiler/index.ts

@@ -0,0 +1,6 @@
+import { baseOptions } from './options'
+import { createCompiler } from 'compiler/index'
+
+const { compile, compileToFunctions } = createCompiler(baseOptions)
+
+export { compile, compileToFunctions }

package/vue2/node_modules/vue/src/platforms/web/compiler/modules/class.ts

@@ -0,0 +1,44 @@
+import { parseText } from 'compiler/parser/text-parser'
+import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
+import { ASTElement, CompilerOptions, ModuleOptions } from 'types/compiler'
+
+function transformNode(el: ASTElement, options: CompilerOptions) {
+  const warn = options.warn || baseWarn
+  const staticClass = getAndRemoveAttr(el, 'class')
+  if (__DEV__ && staticClass) {
+    const res = parseText(staticClass, options.delimiters)
+    if (res) {
+      warn(
+        `class="${staticClass}": ` +
+          'Interpolation inside attributes has been removed. ' +
+          'Use v-bind or the colon shorthand instead. For example, ' +
+          'instead of <div class="{{ val }}">, use <div :class="val">.',
+        el.rawAttrsMap['class']
+      )
+    }
+  }
+  if (staticClass) {
+    el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim())
+  }
+  const classBinding = getBindingAttr(el, 'class', false /* getStatic */)
+  if (classBinding) {
+    el.classBinding = classBinding
+  }
+}
+
+function genData(el: ASTElement): string {
+  let data = ''
+  if (el.staticClass) {
+    data += `staticClass:${el.staticClass},`
+  }
+  if (el.classBinding) {
+    data += `class:${el.classBinding},`
+  }
+  return data
+}
+
+export default {
+  staticKeys: ['staticClass'],
+  transformNode,
+  genData
+} as ModuleOptions

package/vue2/node_modules/vue/src/platforms/web/compiler/modules/index.ts

@@ -0,0 +1,5 @@
+import klass from './class'
+import style from './style'
+import model from './model'
+
+export default [klass, style, model]

package/vue2/node_modules/vue/src/platforms/web/compiler/modules/model.ts

@@ -0,0 +1,89 @@
+/**
+ * Expand input[v-model] with dynamic type bindings into v-if-else chains
+ * Turn this:
+ *   <input v-model="data[type]" :type="type">
+ * into this:
+ *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+ *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+ *   <input v-else :type="type" v-model="data[type]">
+ */
+
+import { addRawAttr, getBindingAttr, getAndRemoveAttr } from 'compiler/helpers'
+
+import {
+  processFor,
+  processElement,
+  addIfCondition,
+  createASTElement
+} from 'compiler/parser/index'
+import { ASTElement, CompilerOptions, ModuleOptions } from 'types/compiler'
+
+function preTransformNode(el: ASTElement, options: CompilerOptions) {
+  if (el.tag === 'input') {
+    const map = el.attrsMap
+    if (!map['v-model']) {
+      return
+    }
+
+    let typeBinding
+    if (map[':type'] || map['v-bind:type']) {
+      typeBinding = getBindingAttr(el, 'type')
+    }
+    if (!map.type && !typeBinding && map['v-bind']) {
+      typeBinding = `(${map['v-bind']}).type`
+    }
+
+    if (typeBinding) {
+      const ifCondition = getAndRemoveAttr(el, 'v-if', true)
+      const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``
+      const hasElse = getAndRemoveAttr(el, 'v-else', true) != null
+      const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true)
+      // 1. checkbox
+      const branch0 = cloneASTElement(el)
+      // process for on the main node
+      processFor(branch0)
+      addRawAttr(branch0, 'type', 'checkbox')
+      processElement(branch0, options)
+      branch0.processed = true // prevent it from double-processed
+      branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra
+      addIfCondition(branch0, {
+        exp: branch0.if,
+        block: branch0
+      })
+      // 2. add radio else-if condition
+      const branch1 = cloneASTElement(el)
+      getAndRemoveAttr(branch1, 'v-for', true)
+      addRawAttr(branch1, 'type', 'radio')
+      processElement(branch1, options)
+      addIfCondition(branch0, {
+        exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+        block: branch1
+      })
+      // 3. other
+      const branch2 = cloneASTElement(el)
+      getAndRemoveAttr(branch2, 'v-for', true)
+      addRawAttr(branch2, ':type', typeBinding)
+      processElement(branch2, options)
+      addIfCondition(branch0, {
+        exp: ifCondition!,
+        block: branch2
+      })
+
+      if (hasElse) {
+        branch0.else = true
+      } else if (elseIfCondition) {
+        branch0.elseif = elseIfCondition
+      }
+
+      return branch0
+    }
+  }
+}
+
+function cloneASTElement(el) {
+  return createASTElement(el.tag, el.attrsList.slice(), el.parent)
+}
+
+export default {
+  preTransformNode
+} as ModuleOptions

package/vue2/node_modules/vue/src/platforms/web/compiler/modules/style.ts

@@ -0,0 +1,47 @@
+import { parseText } from 'compiler/parser/text-parser'
+import { parseStyleText } from 'web/util/style'
+import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
+import { ASTElement, CompilerOptions, ModuleOptions } from 'types/compiler'
+
+function transformNode(el: ASTElement, options: CompilerOptions) {
+  const warn = options.warn || baseWarn
+  const staticStyle = getAndRemoveAttr(el, 'style')
+  if (staticStyle) {
+    /* istanbul ignore if */
+    if (__DEV__) {
+      const res = parseText(staticStyle, options.delimiters)
+      if (res) {
+        warn(
+          `style="${staticStyle}": ` +
+            'Interpolation inside attributes has been removed. ' +
+            'Use v-bind or the colon shorthand instead. For example, ' +
+            'instead of <div style="{{ val }}">, use <div :style="val">.',
+          el.rawAttrsMap['style']
+        )
+      }
+    }
+    el.staticStyle = JSON.stringify(parseStyleText(staticStyle))
+  }
+
+  const styleBinding = getBindingAttr(el, 'style', false /* getStatic */)
+  if (styleBinding) {
+    el.styleBinding = styleBinding
+  }
+}
+
+function genData(el: ASTElement): string {
+  let data = ''
+  if (el.staticStyle) {
+    data += `staticStyle:${el.staticStyle},`
+  }
+  if (el.styleBinding) {
+    data += `style:(${el.styleBinding}),`
+  }
+  return data
+}
+
+export default {
+  staticKeys: ['staticStyle'],
+  transformNode,
+  genData
+} as ModuleOptions

package/vue2/node_modules/vue/src/platforms/web/compiler/options.ts

@@ -0,0 +1,25 @@
+import {
+  isPreTag,
+  mustUseProp,
+  isReservedTag,
+  getTagNamespace
+} from '../util/index'
+
+import modules from './modules/index'
+import directives from './directives/index'
+import { genStaticKeys } from 'shared/util'
+import { isUnaryTag, canBeLeftOpenTag } from './util'
+import { CompilerOptions } from 'types/compiler'
+
+export const baseOptions: CompilerOptions = {
+  expectHTML: true,
+  modules,
+  directives,
+  isPreTag,
+  isUnaryTag,
+  mustUseProp,
+  canBeLeftOpenTag,
+  isReservedTag,
+  getTagNamespace,
+  staticKeys: genStaticKeys(modules)
+}

package/vue2/node_modules/vue/src/platforms/web/compiler/util.ts

@@ -0,0 +1,22 @@
+import { makeMap } from 'shared/util'
+
+export const isUnaryTag = makeMap(
+  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr'
+)
+
+// Elements that you can, intentionally, leave open
+// (and which close themselves)
+export const canBeLeftOpenTag = makeMap(
+  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
+)
+
+// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+export const isNonPhrasingTag = makeMap(
+  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+    'title,tr,track'
+)

package/vue2/node_modules/vue/src/platforms/web/entry-compiler.ts

@@ -0,0 +1,4 @@
+export { parseComponent } from 'sfc/parseComponent'
+export { compile, compileToFunctions } from './compiler/index'
+export { ssrCompile, ssrCompileToFunctions } from 'server/compiler'
+export { generateCodeFrame } from 'compiler/codeframe'

package/vue2/node_modules/vue/src/platforms/web/entry-runtime-esm.ts

@@ -0,0 +1,5 @@
+import Vue from './runtime/index'
+
+export default Vue
+
+export * from 'v3'

package/vue2/node_modules/vue/src/platforms/web/entry-runtime-with-compiler-esm.ts

@@ -0,0 +1,5 @@
+import Vue from './runtime-with-compiler'
+
+export default Vue
+
+export * from 'v3'

package/vue2/node_modules/vue/src/platforms/web/entry-runtime-with-compiler.ts

@@ -0,0 +1,10 @@
+import Vue from './runtime-with-compiler'
+import * as vca from 'v3'
+import { extend } from 'shared/util'
+
+extend(Vue, vca)
+
+import { effect } from 'v3/reactivity/effect'
+Vue.effect = effect
+
+export default Vue

package/vue2/node_modules/vue/src/platforms/web/entry-runtime.ts

@@ -0,0 +1,7 @@
+import Vue from './runtime/index'
+import * as vca from 'v3'
+import { extend } from 'shared/util'
+
+extend(Vue, vca)
+
+export default Vue