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

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

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

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

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

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

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