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

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

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

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

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

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

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

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

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

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