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

package/vue2/node_modules/vue/src/compiler/create-compiler.ts

@@ -0,0 +1,83 @@
+import { extend } from 'shared/util'
+import { CompilerOptions, CompiledResult, WarningMessage } from 'types/compiler'
+import { detectErrors } from './error-detector'
+import { createCompileToFunctionFn } from './to-function'
+
+export function createCompilerCreator(baseCompile: Function): Function {
+  return function createCompiler(baseOptions: CompilerOptions) {
+    function compile(
+      template: string,
+      options?: CompilerOptions
+    ): CompiledResult {
+      const finalOptions = Object.create(baseOptions)
+      const errors: WarningMessage[] = []
+      const tips: WarningMessage[] = []
+
+      let warn = (
+        msg: WarningMessage,
+        range: { start: number; end: number },
+        tip: string
+      ) => {
+        ;(tip ? tips : errors).push(msg)
+      }
+
+      if (options) {
+        if (__DEV__ && options.outputSourceRange) {
+          // $flow-disable-line
+          const leadingSpaceLength = template.match(/^\s*/)![0].length
+
+          warn = (
+            msg: WarningMessage | string,
+            range: { start: number; end: number },
+            tip: string
+          ) => {
+            const data: WarningMessage = typeof msg === 'string' ? { msg } : msg
+            if (range) {
+              if (range.start != null) {
+                data.start = range.start + leadingSpaceLength
+              }
+              if (range.end != null) {
+                data.end = range.end + leadingSpaceLength
+              }
+            }
+            ;(tip ? tips : errors).push(data)
+          }
+        }
+        // merge custom modules
+        if (options.modules) {
+          finalOptions.modules = (baseOptions.modules || []).concat(
+            options.modules
+          )
+        }
+        // merge custom directives
+        if (options.directives) {
+          finalOptions.directives = extend(
+            Object.create(baseOptions.directives || null),
+            options.directives
+          )
+        }
+        // copy other options
+        for (const key in options) {
+          if (key !== 'modules' && key !== 'directives') {
+            finalOptions[key] = options[key as keyof CompilerOptions]
+          }
+        }
+      }
+
+      finalOptions.warn = warn
+
+      const compiled = baseCompile(template.trim(), finalOptions)
+      if (__DEV__) {
+        detectErrors(compiled.ast, warn)
+      }
+      compiled.errors = errors
+      compiled.tips = tips
+      return compiled
+    }
+
+    return {
+      compile,
+      compileToFunctions: createCompileToFunctionFn(compile)
+    }
+  }
+}

package/vue2/node_modules/vue/src/compiler/directives/bind.ts

@@ -0,0 +1,9 @@
+import { ASTDirective, ASTElement } from 'types/compiler'
+
+export default function bind(el: ASTElement, dir: ASTDirective) {
+  el.wrapData = (code: string) => {
+    return `_b(${code},'${el.tag}',${dir.value},${
+      dir.modifiers && dir.modifiers.prop ? 'true' : 'false'
+    }${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`
+  }
+}

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

@@ -0,0 +1,9 @@
+import on from './on'
+import bind from './bind'
+import { noop } from 'shared/util'
+
+export default {
+  on,
+  bind,
+  cloak: noop
+}

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

@@ -0,0 +1,145 @@
+import { ASTElement, ASTModifiers } from 'types/compiler'
+
+/**
+ * Cross-platform code generation for component v-model
+ */
+export function genComponentModel(
+  el: ASTElement,
+  value: string,
+  modifiers: ASTModifiers | null
+): void {
+  const { number, trim } = modifiers || {}
+
+  const baseValueExpression = '$$v'
+  let valueExpression = baseValueExpression
+  if (trim) {
+    valueExpression =
+      `(typeof ${baseValueExpression} === 'string'` +
+      `? ${baseValueExpression}.trim()` +
+      `: ${baseValueExpression})`
+  }
+  if (number) {
+    valueExpression = `_n(${valueExpression})`
+  }
+  const assignment = genAssignmentCode(value, valueExpression)
+
+  el.model = {
+    value: `(${value})`,
+    expression: JSON.stringify(value),
+    callback: `function (${baseValueExpression}) {${assignment}}`
+  }
+}
+
+/**
+ * Cross-platform codegen helper for generating v-model value assignment code.
+ */
+export function genAssignmentCode(value: string, assignment: string): string {
+  const res = parseModel(value)
+  if (res.key === null) {
+    return `${value}=${assignment}`
+  } else {
+    return `$set(${res.exp}, ${res.key}, ${assignment})`
+  }
+}
+
+/**
+ * Parse a v-model expression into a base path and a final key segment.
+ * Handles both dot-path and possible square brackets.
+ *
+ * Possible cases:
+ *
+ * - test
+ * - test[key]
+ * - test[test1[key]]
+ * - test["a"][key]
+ * - xxx.test[a[a].test1[key]]
+ * - test.xxx.a["asa"][test1[key]]
+ *
+ */
+
+let len, str, chr, index, expressionPos, expressionEndPos
+
+type ModelParseResult = {
+  exp: string
+  key: string | null
+}
+
+export function parseModel(val: string): ModelParseResult {
+  // Fix https://github.com/vuejs/vue/pull/7730
+  // allow v-model="obj.val " (trailing whitespace)
+  val = val.trim()
+  len = val.length
+
+  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+    index = val.lastIndexOf('.')
+    if (index > -1) {
+      return {
+        exp: val.slice(0, index),
+        key: '"' + val.slice(index + 1) + '"'
+      }
+    } else {
+      return {
+        exp: val,
+        key: null
+      }
+    }
+  }
+
+  str = val
+  index = expressionPos = expressionEndPos = 0
+
+  while (!eof()) {
+    chr = next()
+    /* istanbul ignore if */
+    if (isStringStart(chr)) {
+      parseString(chr)
+    } else if (chr === 0x5b) {
+      parseBracket(chr)
+    }
+  }
+
+  return {
+    exp: val.slice(0, expressionPos),
+    key: val.slice(expressionPos + 1, expressionEndPos)
+  }
+}
+
+function next(): number {
+  return str.charCodeAt(++index)
+}
+
+function eof(): boolean {
+  return index >= len
+}
+
+function isStringStart(chr: number): boolean {
+  return chr === 0x22 || chr === 0x27
+}
+
+function parseBracket(chr: number): void {
+  let inBracket = 1
+  expressionPos = index
+  while (!eof()) {
+    chr = next()
+    if (isStringStart(chr)) {
+      parseString(chr)
+      continue
+    }
+    if (chr === 0x5b) inBracket++
+    if (chr === 0x5d) inBracket--
+    if (inBracket === 0) {
+      expressionEndPos = index
+      break
+    }
+  }
+}
+
+function parseString(chr: number): void {
+  const stringQuote = chr
+  while (!eof()) {
+    chr = next()
+    if (chr === stringQuote) {
+      break
+    }
+  }
+}

package/vue2/node_modules/vue/src/compiler/directives/on.ts

@@ -0,0 +1,9 @@
+import { warn } from 'core/util/index'
+import { ASTDirective, ASTElement } from 'types/compiler'
+
+export default function on(el: ASTElement, dir: ASTDirective) {
+  if (__DEV__ && dir.modifiers) {
+    warn(`v-on without argument does not support modifiers.`)
+  }
+  el.wrapListeners = (code: string) => `_g(${code},${dir.value})`
+}

package/vue2/node_modules/vue/src/compiler/error-detector.ts

@@ -0,0 +1,158 @@
+import { ASTElement, ASTNode } from 'types/compiler'
+import { dirRE, onRE } from './parser/index'
+
+type Range = { start?: number; end?: number }
+
+// these keywords should not appear inside expressions, but operators like
+// typeof, instanceof and in are allowed
+const prohibitedKeywordRE = new RegExp(
+  '\\b' +
+    (
+      'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+      'super,throw,while,yield,delete,export,import,return,switch,default,' +
+      'extends,finally,continue,debugger,function,arguments'
+    )
+      .split(',')
+      .join('\\b|\\b') +
+    '\\b'
+)
+
+// these unary operators should not be used as property/method names
+const unaryOperatorsRE = new RegExp(
+  '\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)'
+)
+
+// strip strings in expressions
+const stripStringRE =
+  /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g
+
+// detect problematic expressions in a template
+export function detectErrors(ast: ASTNode | undefined, warn: Function) {
+  if (ast) {
+    checkNode(ast, warn)
+  }
+}
+
+function checkNode(node: ASTNode, warn: Function) {
+  if (node.type === 1) {
+    for (const name in node.attrsMap) {
+      if (dirRE.test(name)) {
+        const value = node.attrsMap[name]
+        if (value) {
+          const range = node.rawAttrsMap[name]
+          if (name === 'v-for') {
+            checkFor(node, `v-for="${value}"`, warn, range)
+          } else if (name === 'v-slot' || name[0] === '#') {
+            checkFunctionParameterExpression(
+              value,
+              `${name}="${value}"`,
+              warn,
+              range
+            )
+          } else if (onRE.test(name)) {
+            checkEvent(value, `${name}="${value}"`, warn, range)
+          } else {
+            checkExpression(value, `${name}="${value}"`, warn, range)
+          }
+        }
+      }
+    }
+    if (node.children) {
+      for (let i = 0; i < node.children.length; i++) {
+        checkNode(node.children[i], warn)
+      }
+    }
+  } else if (node.type === 2) {
+    checkExpression(node.expression, node.text, warn, node)
+  }
+}
+
+function checkEvent(exp: string, text: string, warn: Function, range?: Range) {
+  const stripped = exp.replace(stripStringRE, '')
+  const keywordMatch: any = stripped.match(unaryOperatorsRE)
+  if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+    warn(
+      `avoid using JavaScript unary operator as property name: ` +
+        `"${keywordMatch[0]}" in expression ${text.trim()}`,
+      range
+    )
+  }
+  checkExpression(exp, text, warn, range)
+}
+
+function checkFor(
+  node: ASTElement,
+  text: string,
+  warn: Function,
+  range?: Range
+) {
+  checkExpression(node.for || '', text, warn, range)
+  checkIdentifier(node.alias, 'v-for alias', text, warn, range)
+  checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range)
+  checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range)
+}
+
+function checkIdentifier(
+  ident: string | null | undefined,
+  type: string,
+  text: string,
+  warn: Function,
+  range?: Range
+) {
+  if (typeof ident === 'string') {
+    try {
+      new Function(`var ${ident}=_`)
+    } catch (e: any) {
+      warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range)
+    }
+  }
+}
+
+function checkExpression(
+  exp: string,
+  text: string,
+  warn: Function,
+  range?: Range
+) {
+  try {
+    new Function(`return ${exp}`)
+  } catch (e: any) {
+    const keywordMatch = exp
+      .replace(stripStringRE, '')
+      .match(prohibitedKeywordRE)
+    if (keywordMatch) {
+      warn(
+        `avoid using JavaScript keyword as property name: ` +
+          `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`,
+        range
+      )
+    } else {
+      warn(
+        `invalid expression: ${e.message} in\n\n` +
+          `    ${exp}\n\n` +
+          `  Raw expression: ${text.trim()}\n`,
+        range
+      )
+    }
+  }
+}
+
+function checkFunctionParameterExpression(
+  exp: string,
+  text: string,
+  warn: Function,
+  range?: Range
+) {
+  try {
+    new Function(exp, '')
+  } catch (e: any) {
+    warn(
+      `invalid function parameter expression: ${e.message} in\n\n` +
+        `    ${exp}\n\n` +
+        `  Raw expression: ${text.trim()}\n`,
+      range
+    )
+  }
+}

package/vue2/node_modules/vue/src/compiler/helpers.ts

@@ -0,0 +1,243 @@
+import { emptyObject } from 'shared/util'
+import { ASTElement, ASTModifiers } from 'types/compiler'
+import { parseFilters } from './parser/filter-parser'
+
+type Range = { start?: number; end?: number }
+
+/* eslint-disable no-unused-vars */
+export function baseWarn(msg: string, range?: Range) {
+  console.error(`[Vue compiler]: ${msg}`)
+}
+/* eslint-enable no-unused-vars */
+
+export function pluckModuleFunction<T, K extends keyof T>(
+  modules: Array<T> | undefined,
+  key: K
+): Array<Exclude<T[K], undefined>> {
+  return modules ? (modules.map(m => m[key]).filter(_ => _) as any) : []
+}
+
+export function addProp(
+  el: ASTElement,
+  name: string,
+  value: string,
+  range?: Range,
+  dynamic?: boolean
+) {
+  ;(el.props || (el.props = [])).push(
+    rangeSetItem({ name, value, dynamic }, range)
+  )
+  el.plain = false
+}
+
+export function addAttr(
+  el: ASTElement,
+  name: string,
+  value: any,
+  range?: Range,
+  dynamic?: boolean
+) {
+  const attrs = dynamic
+    ? el.dynamicAttrs || (el.dynamicAttrs = [])
+    : el.attrs || (el.attrs = [])
+  attrs.push(rangeSetItem({ name, value, dynamic }, range))
+  el.plain = false
+}
+
+// add a raw attr (use this in preTransforms)
+export function addRawAttr(
+  el: ASTElement,
+  name: string,
+  value: any,
+  range?: Range
+) {
+  el.attrsMap[name] = value
+  el.attrsList.push(rangeSetItem({ name, value }, range))
+}
+
+export function addDirective(
+  el: ASTElement,
+  name: string,
+  rawName: string,
+  value: string,
+  arg?: string,
+  isDynamicArg?: boolean,
+  modifiers?: ASTModifiers,
+  range?: Range
+) {
+  ;(el.directives || (el.directives = [])).push(
+    rangeSetItem(
+      {
+        name,
+        rawName,
+        value,
+        arg,
+        isDynamicArg,
+        modifiers
+      },
+      range
+    )
+  )
+  el.plain = false
+}
+
+function prependModifierMarker(
+  symbol: string,
+  name: string,
+  dynamic?: boolean
+): string {
+  return dynamic ? `_p(${name},"${symbol}")` : symbol + name // mark the event as captured
+}
+
+export function addHandler(
+  el: ASTElement,
+  name: string,
+  value: string,
+  modifiers?: ASTModifiers | null,
+  important?: boolean,
+  warn?: Function,
+  range?: Range,
+  dynamic?: boolean
+) {
+  modifiers = modifiers || emptyObject
+  // warn prevent and passive modifier
+  /* istanbul ignore if */
+  if (__DEV__ && warn && modifiers.prevent && modifiers.passive) {
+    warn(
+      "passive and prevent can't be used together. " +
+        "Passive handler can't prevent default event.",
+      range
+    )
+  }
+
+  // normalize click.right and click.middle since they don't actually fire
+  // this is technically browser-specific, but at least for now browsers are
+  // the only target envs that have right/middle clicks.
+  if (modifiers.right) {
+    if (dynamic) {
+      name = `(${name})==='click'?'contextmenu':(${name})`
+    } else if (name === 'click') {
+      name = 'contextmenu'
+      delete modifiers.right
+    }
+  } else if (modifiers.middle) {
+    if (dynamic) {
+      name = `(${name})==='click'?'mouseup':(${name})`
+    } else if (name === 'click') {
+      name = 'mouseup'
+    }
+  }
+
+  // check capture modifier
+  if (modifiers.capture) {
+    delete modifiers.capture
+    name = prependModifierMarker('!', name, dynamic)
+  }
+  if (modifiers.once) {
+    delete modifiers.once
+    name = prependModifierMarker('~', name, dynamic)
+  }
+  /* istanbul ignore if */
+  if (modifiers.passive) {
+    delete modifiers.passive
+    name = prependModifierMarker('&', name, dynamic)
+  }
+
+  let events
+  if (modifiers.native) {
+    delete modifiers.native
+    events = el.nativeEvents || (el.nativeEvents = {})
+  } else {
+    events = el.events || (el.events = {})
+  }
+
+  const newHandler: any = rangeSetItem({ value: value.trim(), dynamic }, range)
+  if (modifiers !== emptyObject) {
+    newHandler.modifiers = modifiers
+  }
+
+  const handlers = events[name]
+  /* istanbul ignore if */
+  if (Array.isArray(handlers)) {
+    important ? handlers.unshift(newHandler) : handlers.push(newHandler)
+  } else if (handlers) {
+    events[name] = important ? [newHandler, handlers] : [handlers, newHandler]
+  } else {
+    events[name] = newHandler
+  }
+
+  el.plain = false
+}
+
+export function getRawBindingAttr(el: ASTElement, name: string) {
+  return (
+    el.rawAttrsMap[':' + name] ||
+    el.rawAttrsMap['v-bind:' + name] ||
+    el.rawAttrsMap[name]
+  )
+}
+
+export function getBindingAttr(
+  el: ASTElement,
+  name: string,
+  getStatic?: boolean
+): string | undefined {
+  const dynamicValue =
+    getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name)
+  if (dynamicValue != null) {
+    return parseFilters(dynamicValue)
+  } else if (getStatic !== false) {
+    const staticValue = getAndRemoveAttr(el, name)
+    if (staticValue != null) {
+      return JSON.stringify(staticValue)
+    }
+  }
+}
+
+// note: this only removes the attr from the Array (attrsList) so that it
+// doesn't get processed by processAttrs.
+// By default it does NOT remove it from the map (attrsMap) because the map is
+// needed during codegen.
+export function getAndRemoveAttr(
+  el: ASTElement,
+  name: string,
+  removeFromMap?: boolean
+): string | undefined {
+  let val
+  if ((val = el.attrsMap[name]) != null) {
+    const list = el.attrsList
+    for (let i = 0, l = list.length; i < l; i++) {
+      if (list[i].name === name) {
+        list.splice(i, 1)
+        break
+      }
+    }
+  }
+  if (removeFromMap) {
+    delete el.attrsMap[name]
+  }
+  return val
+}
+
+export function getAndRemoveAttrByRegex(el: ASTElement, name: RegExp) {
+  const list = el.attrsList
+  for (let i = 0, l = list.length; i < l; i++) {
+    const attr = list[i]
+    if (name.test(attr.name)) {
+      list.splice(i, 1)
+      return attr
+    }
+  }
+}
+
+function rangeSetItem(item: any, range?: { start?: number; end?: number }) {
+  if (range) {
+    if (range.start != null) {
+      item.start = range.start
+    }
+    if (range.end != null) {
+      item.end = range.end
+    }
+  }
+  return item
+}

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

@@ -0,0 +1,24 @@
+import { parse } from './parser/index'
+import { optimize } from './optimizer'
+import { generate } from './codegen/index'
+import { createCompilerCreator } from './create-compiler'
+import { CompilerOptions, CompiledResult } from 'types/compiler'
+
+// `createCompilerCreator` allows creating compilers that use alternative
+// parser/optimizer/codegen, e.g the SSR optimizing compiler.
+// Here we just export a default compiler using the default parts.
+export const createCompiler = createCompilerCreator(function baseCompile(
+  template: string,
+  options: CompilerOptions
+): CompiledResult {
+  const ast = parse(template.trim(), options)
+  if (options.optimize !== false) {
+    optimize(ast, options)
+  }
+  const code = generate(ast, options)
+  return {
+    ast,
+    render: code.render,
+    staticRenderFns: code.staticRenderFns
+  }
+})