@builder.io/sdk-vue 0.5.9 → 0.6.0

package/vue2/node_modules/vue/packages/compiler-sfc/src/parseComponent.ts

@@ -0,0 +1,220 @@
+import deindent from 'de-indent'
+import { parseHTML } from 'compiler/parser/html-parser'
+import { makeMap } from 'shared/util'
+import { ASTAttr, WarningMessage } from 'types/compiler'
+import { BindingMetadata, RawSourceMap } from './types'
+import type { ImportBinding } from './compileScript'
+
+export const DEFAULT_FILENAME = 'anonymous.vue'
+
+const splitRE = /\r?\n/g
+const replaceRE = /./g
+const isSpecialTag = makeMap('script,style,template', true)
+
+export interface SFCCustomBlock {
+  type: string
+  content: string
+  attrs: { [key: string]: string | true }
+  start: number
+  end: number
+  src?: string
+  map?: RawSourceMap
+}
+
+export interface SFCBlock extends SFCCustomBlock {
+  lang?: string
+  scoped?: boolean
+  module?: string | boolean
+}
+
+export interface SFCScriptBlock extends SFCBlock {
+  type: 'script'
+  setup?: string | boolean
+  bindings?: BindingMetadata
+  imports?: Record<string, ImportBinding>
+  /**
+   * import('\@babel/types').Statement
+   */
+  scriptAst?: any[]
+  /**
+   * import('\@babel/types').Statement
+   */
+  scriptSetupAst?: any[]
+}
+
+export interface SFCDescriptor {
+  source: string
+  filename: string
+  template: SFCBlock | null
+  script: SFCScriptBlock | null
+  scriptSetup: SFCScriptBlock | null
+  styles: SFCBlock[]
+  customBlocks: SFCCustomBlock[]
+  cssVars: string[]
+
+  errors: (string | WarningMessage)[]
+
+  /**
+   * compare with an existing descriptor to determine whether HMR should perform
+   * a reload vs. re-render.
+   *
+   * Note: this comparison assumes the prev/next script are already identical,
+   * and only checks the special case where `<script setup lang="ts">` unused
+   * import pruning result changes due to template changes.
+   */
+  shouldForceReload: (prevImports: Record<string, ImportBinding>) => boolean
+}
+
+export interface VueTemplateCompilerParseOptions {
+  pad?: 'line' | 'space' | boolean
+  deindent?: boolean
+  outputSourceRange?: boolean
+}
+
+/**
+ * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
+ */
+export function parseComponent(
+  source: string,
+  options: VueTemplateCompilerParseOptions = {}
+): SFCDescriptor {
+  const sfc: SFCDescriptor = {
+    source,
+    filename: DEFAULT_FILENAME,
+    template: null,
+    script: null,
+    scriptSetup: null, // TODO
+    styles: [],
+    customBlocks: [],
+    cssVars: [],
+    errors: [],
+    shouldForceReload: null as any // attached in parse() by compiler-sfc
+  }
+  let depth = 0
+  let currentBlock: SFCBlock | null = null
+
+  let warn: any = msg => {
+    sfc.errors.push(msg)
+  }
+
+  if (__DEV__ && options.outputSourceRange) {
+    warn = (msg, range) => {
+      const data: WarningMessage = { msg }
+      if (range.start != null) {
+        data.start = range.start
+      }
+      if (range.end != null) {
+        data.end = range.end
+      }
+      sfc.errors.push(data)
+    }
+  }
+
+  function start(
+    tag: string,
+    attrs: ASTAttr[],
+    unary: boolean,
+    start: number,
+    end: number
+  ) {
+    if (depth === 0) {
+      currentBlock = {
+        type: tag,
+        content: '',
+        start: end,
+        end: 0, // will be set on tag close
+        attrs: attrs.reduce((cumulated, { name, value }) => {
+          cumulated[name] = value || true
+          return cumulated
+        }, {})
+      }
+
+      if (typeof currentBlock.attrs.src === 'string') {
+        currentBlock.src = currentBlock.attrs.src
+      }
+
+      if (isSpecialTag(tag)) {
+        checkAttrs(currentBlock, attrs)
+        if (tag === 'script') {
+          const block = currentBlock as SFCScriptBlock
+          if (block.attrs.setup) {
+            block.setup = currentBlock.attrs.setup
+            sfc.scriptSetup = block
+          } else {
+            sfc.script = block
+          }
+        } else if (tag === 'style') {
+          sfc.styles.push(currentBlock)
+        } else {
+          sfc[tag] = currentBlock
+        }
+      } else {
+        // custom blocks
+        sfc.customBlocks.push(currentBlock)
+      }
+    }
+    if (!unary) {
+      depth++
+    }
+  }
+
+  function checkAttrs(block: SFCBlock, attrs: ASTAttr[]) {
+    for (let i = 0; i < attrs.length; i++) {
+      const attr = attrs[i]
+      if (attr.name === 'lang') {
+        block.lang = attr.value
+      }
+      if (attr.name === 'scoped') {
+        block.scoped = true
+      }
+      if (attr.name === 'module') {
+        block.module = attr.value || true
+      }
+    }
+  }
+
+  function end(tag: string, start: number) {
+    if (depth === 1 && currentBlock) {
+      currentBlock.end = start
+      let text = source.slice(currentBlock.start, currentBlock.end)
+      if (
+        options.deindent === true ||
+        // by default, deindent unless it's script with default lang or (j/t)sx?
+        (options.deindent !== false &&
+          !(
+            currentBlock.type === 'script' &&
+            (!currentBlock.lang || /^(j|t)sx?$/.test(currentBlock.lang))
+          ))
+      ) {
+        text = deindent(text)
+      }
+      // pad content so that linters and pre-processors can output correct
+      // line numbers in errors and warnings
+      if (currentBlock.type !== 'template' && options.pad) {
+        text = padContent(currentBlock, options.pad) + text
+      }
+      currentBlock.content = text
+      currentBlock = null
+    }
+    depth--
+  }
+
+  function padContent(block: SFCBlock, pad: true | 'line' | 'space') {
+    if (pad === 'space') {
+      return source.slice(0, block.start).replace(replaceRE, ' ')
+    } else {
+      const offset = source.slice(0, block.start).split(splitRE).length
+      const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n'
+      return Array(offset).join(padChar)
+    }
+  }
+
+  parseHTML(source, {
+    warn,
+    start,
+    end,
+    outputSourceRange: options.outputSourceRange
+  })
+
+  return sfc
+}

package/vue2/node_modules/vue/packages/compiler-sfc/src/prefixIdentifiers.ts

@@ -0,0 +1,82 @@
+import MagicString from 'magic-string'
+import { parseExpression, ParserOptions, ParserPlugin } from '@babel/parser'
+import { makeMap } from 'shared/util'
+import { isStaticProperty, walkIdentifiers } from './babelUtils'
+import { BindingMetadata } from './types'
+
+const doNotPrefix = makeMap(
+  'Infinity,undefined,NaN,isFinite,isNaN,' +
+    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
+    'require,' + // for webpack
+    'arguments,' + // parsed as identifier but is a special keyword...
+    '_c' // cached to save property access
+)
+
+/**
+ * The input is expected to be a valid expression.
+ */
+export function prefixIdentifiers(
+  source: string,
+  isFunctional = false,
+  isTS = false,
+  babelOptions: ParserOptions = {},
+  bindings?: BindingMetadata
+) {
+  const s = new MagicString(source)
+
+  const plugins: ParserPlugin[] = [
+    ...(isTS ? (['typescript'] as const) : []),
+    ...(babelOptions?.plugins || [])
+  ]
+
+  const ast = parseExpression(source, {
+    ...babelOptions,
+    plugins
+  })
+
+  const isScriptSetup = bindings && bindings.__isScriptSetup !== false
+
+  walkIdentifiers(
+    ast,
+    (ident, parent) => {
+      const { name } = ident
+      if (doNotPrefix(name)) {
+        return
+      }
+
+      let prefix = `_vm.`
+      if (isScriptSetup) {
+        const type = bindings[name]
+        if (type && type.startsWith('setup')) {
+          prefix = `_setup.`
+        }
+      }
+
+      if (isStaticProperty(parent) && parent.shorthand) {
+        // property shorthand like { foo }, we need to add the key since
+        // we rewrite the value
+        // { foo } -> { foo: _vm.foo }
+        s.appendLeft(ident.end!, `: ${prefix}${name}`)
+      } else {
+        s.prependRight(ident.start!, prefix)
+      }
+    },
+    node => {
+      if (node.type === 'WithStatement') {
+        s.remove(node.start!, node.body.start! + 1)
+        s.remove(node.end! - 1, node.end!)
+        if (!isFunctional) {
+          s.prependRight(
+            node.start!,
+            `var _vm=this,_c=_vm._self._c${
+              isScriptSetup ? `,_setup=_vm._self._setupProxy;` : `;`
+            }`
+          )
+        }
+      }
+    }
+  )
+
+  return s.toString()
+}

package/vue2/node_modules/vue/packages/compiler-sfc/src/rewriteDefault.ts

@@ -0,0 +1,115 @@
+import { parse, ParserPlugin } from '@babel/parser'
+import MagicString from 'magic-string'
+
+const defaultExportRE = /((?:^|\n|;)\s*)export(\s*)default/
+const namedDefaultExportRE = /((?:^|\n|;)\s*)export(.+)(?:as)?(\s*)default/s
+const exportDefaultClassRE =
+  /((?:^|\n|;)\s*)export\s+default\s+class\s+([\w$]+)/
+
+/**
+ * Utility for rewriting `export default` in a script block into a variable
+ * declaration so that we can inject things into it
+ */
+export function rewriteDefault(
+  input: string,
+  as: string,
+  parserPlugins?: ParserPlugin[]
+): string {
+  if (!hasDefaultExport(input)) {
+    return input + `\nconst ${as} = {}`
+  }
+
+  let replaced: string | undefined
+
+  const classMatch = input.match(exportDefaultClassRE)
+  if (classMatch) {
+    replaced =
+      input.replace(exportDefaultClassRE, '$1class $2') +
+      `\nconst ${as} = ${classMatch[2]}`
+  } else {
+    replaced = input.replace(defaultExportRE, `$1const ${as} =`)
+  }
+  if (!hasDefaultExport(replaced)) {
+    return replaced
+  }
+
+  // if the script somehow still contains `default export`, it probably has
+  // multi-line comments or template strings. fallback to a full parse.
+  const s = new MagicString(input)
+  const ast = parse(input, {
+    sourceType: 'module',
+    plugins: parserPlugins
+  }).program.body
+  ast.forEach(node => {
+    if (node.type === 'ExportDefaultDeclaration') {
+      if (node.declaration.type === 'ClassDeclaration') {
+        s.overwrite(node.start!, node.declaration.id.start!, `class `)
+        s.append(`\nconst ${as} = ${node.declaration.id.name}`)
+      } else {
+        s.overwrite(node.start!, node.declaration.start!, `const ${as} = `)
+      }
+    }
+    if (node.type === 'ExportNamedDeclaration') {
+      for (const specifier of node.specifiers) {
+        if (
+          specifier.type === 'ExportSpecifier' &&
+          specifier.exported.type === 'Identifier' &&
+          specifier.exported.name === 'default'
+        ) {
+          if (node.source) {
+            if (specifier.local.name === 'default') {
+              const end = specifierEnd(input, specifier.local.end!, node.end)
+              s.prepend(
+                `import { default as __VUE_DEFAULT__ } from '${node.source.value}'\n`
+              )
+              s.overwrite(specifier.start!, end, ``)
+              s.append(`\nconst ${as} = __VUE_DEFAULT__`)
+              continue
+            } else {
+              const end = specifierEnd(input, specifier.exported.end!, node.end)
+              s.prepend(
+                `import { ${input.slice(
+                  specifier.local.start!,
+                  specifier.local.end!
+                )} } from '${node.source.value}'\n`
+              )
+              s.overwrite(specifier.start!, end, ``)
+              s.append(`\nconst ${as} = ${specifier.local.name}`)
+              continue
+            }
+          }
+          const end = specifierEnd(input, specifier.end!, node.end)
+          s.overwrite(specifier.start!, end, ``)
+          s.append(`\nconst ${as} = ${specifier.local.name}`)
+        }
+      }
+    }
+  })
+  return s.toString()
+}
+
+export function hasDefaultExport(input: string): boolean {
+  return defaultExportRE.test(input) || namedDefaultExportRE.test(input)
+}
+
+function specifierEnd(
+  input: string,
+  end: number,
+  nodeEnd: number | undefined | null
+) {
+  // export { default   , foo } ...
+  let hasCommas = false
+  let oldEnd = end
+  while (end < nodeEnd!) {
+    if (/\s/.test(input.charAt(end))) {
+      end++
+    } else if (input.charAt(end) === ',') {
+      end++
+      hasCommas = true
+      break
+    } else if (input.charAt(end) === '}') {
+      break
+    }
+  }
+  return hasCommas ? end : oldEnd
+}

package/vue2/node_modules/vue/packages/compiler-sfc/src/stylePlugins/scoped.ts

@@ -0,0 +1,203 @@
+import { PluginCreator, Rule, AtRule } from 'postcss'
+import selectorParser from 'postcss-selector-parser'
+
+const animationNameRE = /^(-\w+-)?animation-name$/
+const animationRE = /^(-\w+-)?animation$/
+
+const scopedPlugin: PluginCreator<string> = (id = '') => {
+  const keyframes = Object.create(null)
+  const shortId = id.replace(/^data-v-/, '')
+
+  return {
+    postcssPlugin: 'vue-sfc-scoped',
+    Rule(rule) {
+      processRule(id, rule)
+    },
+    AtRule(node) {
+      if (
+        /-?keyframes$/.test(node.name) &&
+        !node.params.endsWith(`-${shortId}`)
+      ) {
+        // register keyframes
+        keyframes[node.params] = node.params = node.params + '-' + shortId
+      }
+    },
+    OnceExit(root) {
+      if (Object.keys(keyframes).length) {
+        // If keyframes are found in this <style>, find and rewrite animation names
+        // in declarations.
+        // Caveat: this only works for keyframes and animation rules in the same
+        // <style> element.
+        // individual animation-name declaration
+        root.walkDecls(decl => {
+          if (animationNameRE.test(decl.prop)) {
+            decl.value = decl.value
+              .split(',')
+              .map(v => keyframes[v.trim()] || v.trim())
+              .join(',')
+          }
+          // shorthand
+          if (animationRE.test(decl.prop)) {
+            decl.value = decl.value
+              .split(',')
+              .map(v => {
+                const vals = v.trim().split(/\s+/)
+                const i = vals.findIndex(val => keyframes[val])
+                if (i !== -1) {
+                  vals.splice(i, 1, keyframes[vals[i]])
+                  return vals.join(' ')
+                } else {
+                  return v
+                }
+              })
+              .join(',')
+          }
+        })
+      }
+    }
+  }
+}
+
+const processedRules = new WeakSet<Rule>()
+
+function processRule(id: string, rule: Rule) {
+  if (
+    processedRules.has(rule) ||
+    (rule.parent &&
+      rule.parent.type === 'atrule' &&
+      /-?keyframes$/.test((rule.parent as AtRule).name))
+  ) {
+    return
+  }
+  processedRules.add(rule)
+  rule.selector = selectorParser(selectorRoot => {
+    selectorRoot.each(selector => {
+      rewriteSelector(id, selector, selectorRoot)
+    })
+  }).processSync(rule.selector)
+}
+
+function rewriteSelector(
+  id: string,
+  selector: selectorParser.Selector,
+  selectorRoot: selectorParser.Root
+) {
+  let node: selectorParser.Node | null = null
+  let shouldInject = true
+  // find the last child node to insert attribute selector
+  selector.each(n => {
+    // DEPRECATED ">>>" and "/deep/" combinator
+    if (
+      n.type === 'combinator' &&
+      (n.value === '>>>' || n.value === '/deep/')
+    ) {
+      n.value = ' '
+      n.spaces.before = n.spaces.after = ''
+      // warn(
+      //   `the >>> and /deep/ combinators have been deprecated. ` +
+      //     `Use :deep() instead.`
+      // )
+      return false
+    }
+
+    if (n.type === 'pseudo') {
+      const { value } = n
+      // deep: inject [id] attribute at the node before the ::v-deep
+      // combinator.
+      if (value === ':deep' || value === '::v-deep') {
+        if (n.nodes.length) {
+          // .foo ::v-deep(.bar) -> .foo[xxxxxxx] .bar
+          // replace the current node with ::v-deep's inner selector
+          let last: selectorParser.Selector['nodes'][0] = n
+          n.nodes[0].each(ss => {
+            selector.insertAfter(last, ss)
+            last = ss
+          })
+          // insert a space combinator before if it doesn't already have one
+          const prev = selector.at(selector.index(n) - 1)
+          if (!prev || !isSpaceCombinator(prev)) {
+            selector.insertAfter(
+              n,
+              selectorParser.combinator({
+                value: ' '
+              })
+            )
+          }
+          selector.removeChild(n)
+        } else {
+          // DEPRECATED usage in v3
+          // .foo ::v-deep .bar -> .foo[xxxxxxx] .bar
+          // warn(
+          //   `::v-deep usage as a combinator has ` +
+          //     `been deprecated. Use :deep(<inner-selector>) instead.`
+          // )
+          const prev = selector.at(selector.index(n) - 1)
+          if (prev && isSpaceCombinator(prev)) {
+            selector.removeChild(prev)
+          }
+          selector.removeChild(n)
+        }
+        return false
+      }
+
+      // !!! Vue 2 does not have :slotted support
+      // ::v-slotted(.foo) -> .foo[xxxxxxx-s]
+      // if (value === ':slotted' || value === '::v-slotted') {
+      //   rewriteSelector(id, n.nodes[0], selectorRoot, true /* slotted */)
+      //   let last: selectorParser.Selector['nodes'][0] = n
+      //   n.nodes[0].each(ss => {
+      //     selector.insertAfter(last, ss)
+      //     last = ss
+      //   })
+      //   // selector.insertAfter(n, n.nodes[0])
+      //   selector.removeChild(n)
+      //   // since slotted attribute already scopes the selector there's no
+      //   // need for the non-slot attribute.
+      //   shouldInject = false
+      //   return false
+      // }
+
+      // global: replace with inner selector and do not inject [id].
+      // ::v-global(.foo) -> .foo
+      if (value === ':global' || value === '::v-global') {
+        selectorRoot.insertAfter(selector, n.nodes[0])
+        selectorRoot.removeChild(selector)
+        return false
+      }
+    }
+
+    if (n.type !== 'pseudo' && n.type !== 'combinator') {
+      node = n
+    }
+  })
+
+  if (node) {
+    ;(node as selectorParser.Node).spaces.after = ''
+  } else {
+    // For deep selectors & standalone pseudo selectors,
+    // the attribute selectors are prepended rather than appended.
+    // So all leading spaces must be eliminated to avoid problems.
+    selector.first.spaces.before = ''
+  }
+
+  if (shouldInject) {
+    selector.insertAfter(
+      // If node is null it means we need to inject [id] at the start
+      // insertAfter can handle `null` here
+      node as any,
+      selectorParser.attribute({
+        attribute: id,
+        value: id,
+        raws: {},
+        quoteMark: `"`
+      })
+    )
+  }
+}
+
+function isSpaceCombinator(node: selectorParser.Node) {
+  return node.type === 'combinator' && /^\s+$/.test(node.value)
+}
+
+scopedPlugin.postcss = true
+export default scopedPlugin

package/vue2/node_modules/vue/packages/compiler-sfc/src/stylePlugins/trim.ts

@@ -0,0 +1,18 @@
+import { PluginCreator } from 'postcss'
+
+const trimPlugin: PluginCreator<{}> = () => {
+  return {
+    postcssPlugin: 'vue-sfc-trim',
+    Once(root) {
+      root.walk(({ type, raws }) => {
+        if (type === 'rule' || type === 'atrule') {
+          if (raws.before) raws.before = '\n'
+          if ('after' in raws && raws.after) raws.after = '\n'
+        }
+      })
+    }
+  }
+}
+
+trimPlugin.postcss = true
+export default trimPlugin