vue3-yuanma/packages/compiler-sfc/__tests__/__snapshots__/compileScript.spec.ts.snap

// Jest Snapshot v1, https://goo.gl/fbAQLP

exports[`SFC compile <script setup> CSS vars injection <script> w/ default export 1`] = `
"const __default__ = { setup() {} }
import { useCssVars as __useCssVars__ } from 'vue'
const __injectCSSVars__ = () => {
__useCssVars__(_ctx => ({ color: _ctx.color }))
}
const __setup__ = __default__.setup
__default__.setup = __setup__
  ? (props, ctx) => { __injectCSSVars__();return __setup__(props, ctx) }
  : __injectCSSVars__
export default __default__"
`;

exports[`SFC compile <script setup> CSS vars injection <script> w/ default export in strings/comments 1`] = `
"
          // export default {}
          const __default__ = {}
        
import { useCssVars as __useCssVars__ } from 'vue'
const __injectCSSVars__ = () => {
__useCssVars__(_ctx => ({ color: _ctx.color }))
}
const __setup__ = __default__.setup
__default__.setup = __setup__
  ? (props, ctx) => { __injectCSSVars__();return __setup__(props, ctx) }
  : __injectCSSVars__
export default __default__"
`;

exports[`SFC compile <script setup> CSS vars injection <script> w/ no default export 1`] = `
"const a = 1
const __default__ = {}
import { useCssVars as __useCssVars__ } from 'vue'
const __injectCSSVars__ = () => {
__useCssVars__(_ctx => ({ color: _ctx.color }))
}
const __setup__ = __default__.setup
__default__.setup = __setup__
  ? (props, ctx) => { __injectCSSVars__();return __setup__(props, ctx) }
  : __injectCSSVars__
export default __default__"
`;

exports[`SFC compile <script setup> CSS vars injection w/ <script setup> 1`] = `
"import { useCssVars } from 'vue'

export default {
  setup() {
const color = 'red'
__useCssVars__(_ctx => ({ color }))
return { color }
}

}"
`;

exports[`SFC compile <script setup> errors should allow useOptions() referencing imported binding 1`] = `
"import { bar } from './bar'
          
export default {
  props: {
              foo: {
                default: () => bar
              }
            },
  setup() {

          
        
return { bar }
}

}"
`;

exports[`SFC compile <script setup> errors should allow useOptions() referencing scope var 1`] = `
"export default {
  props: {
              foo: {
                default: bar => bar + 1
              }
            },
  setup() {

          const bar = 1
          
        
return { bar }
}

}"
`;

exports[`SFC compile <script setup> imports dedupe between user & helper 1`] = `
"import { ref } from 'vue'
      
export default {
  setup() {

      const foo = ref(1)
      
return { foo, ref }
}

}"
`;

exports[`SFC compile <script setup> imports import dedupe between <script> and <script setup> 1`] = `
"import { x } from './x'
        
export default {
  setup() {

        x()
        
return { x }
}

}"
`;

exports[`SFC compile <script setup> imports should extract comment for import or type declarations 1`] = `
"import a from 'a' // comment
        import b from 'b'
        
export default {
  setup() {

        
return { a, b }
}

}"
`;

exports[`SFC compile <script setup> imports should hoist and expose imports 1`] = `
"import { ref } from 'vue'
export default {
  setup() {

return { ref }
}

}"
`;

exports[`SFC compile <script setup> inlineTemplate mode avoid unref() when necessary 1`] = `
"import { createVNode as _createVNode, unref as _unref, toDisplayString as _toDisplayString, Fragment as _Fragment, openBlock as _openBlock, createBlock as _createBlock } from \\"vue\\"

import { ref } from 'vue'
        import Foo from './Foo.vue'
        import other from './util'
        
export default {
  setup() {

        const count = ref(0)
        const constant = {}
        function fn() {}
        
return (_ctx, _cache, $props, $setup, $data, $options) => {
  return (_openBlock(), _createBlock(_Fragment, null, [
    _createVNode(Foo),
    _createVNode(\\"div\\", { onClick: fn }, _toDisplayString(_unref(count)) + \\" \\" + _toDisplayString(constant) + \\" \\" + _toDisplayString(_unref(other)), 1 /* TEXT */)
  ], 64 /* STABLE_FRAGMENT */))
}
}

}"
`;

exports[`SFC compile <script setup> inlineTemplate mode should work 1`] = `
"import { unref as _unref, toDisplayString as _toDisplayString, createVNode as _createVNode, Fragment as _Fragment, openBlock as _openBlock, createBlock as _createBlock } from \\"vue\\"

const _hoisted_1 = /*#__PURE__*/_createVNode(\\"div\\", null, \\"static\\", -1 /* HOISTED */)

import { ref } from 'vue'
        
export default {
  setup() {

        const count = ref(0)
        
return (_ctx, _cache, $props, $setup, $data, $options) => {
  return (_openBlock(), _createBlock(_Fragment, null, [
    _createVNode(\\"div\\", null, _toDisplayString(_unref(count)), 1 /* TEXT */),
    _hoisted_1
  ], 64 /* STABLE_FRAGMENT */))
}
}

}"
`;

exports[`SFC compile <script setup> ref: syntax sugar accessing ref binding 1`] = `
"import { ref } from 'vue'

export default {
  setup() {

      const a = ref(1)
      console.log(a.value)
      function get() {
        return a.value + 1
      }
      
return { a, get }
}

}"
`;

exports[`SFC compile <script setup> ref: syntax sugar array destructure 1`] = `
"import { ref } from 'vue'

export default {
  setup() {

      const n = ref(1), [__a, __b = 1, ...__c] = useFoo()
const a = ref(__a);
const b = ref(__b);
const c = ref(__c);
      console.log(n.value, a.value, b.value, c.value)
      
return { n, a, b, c }
}

}"
`;

exports[`SFC compile <script setup> ref: syntax sugar convert ref declarations 1`] = `
"import { ref } from 'vue'

export default {
  setup() {

      const foo = ref()
      const a = ref(1)
      const b = ref({
        count: 0
      })
      let c = () => {}
      let d
      
return { foo, a, b, c, d }
}

}"
`;

exports[`SFC compile <script setup> ref: syntax sugar multi ref declarations 1`] = `
"import { ref } from 'vue'

export default {
  setup() {

      const a = ref(1), b = ref(2), c = ref({
        count: 0
      })
      
return { a, b, c }
}

}"
`;

exports[`SFC compile <script setup> ref: syntax sugar mutating ref binding 1`] = `
"import { ref } from 'vue'

export default {
  setup() {

      const a = ref(1)
      const b = ref({ count: 0 })
      function inc() {
        a.value++
        a.value = a.value + 1
        b.value.count++
        b.value.count = b.value.count + 1
      }
      
return { a, b, inc }
}

}"
`;

exports[`SFC compile <script setup> ref: syntax sugar nested destructure 1`] = `
"import { ref } from 'vue'

export default {
  setup() {

      const [{ a: { b: __b }}] = useFoo()
const b = ref(__b);
      const { c: [__d, __e] } = useBar()
const d = ref(__d);
const e = ref(__e);
      console.log(b.value, d.value, e.value)
      
return { b, d, e }
}

}"
`;

exports[`SFC compile <script setup> ref: syntax sugar object destructure 1`] = `
"import { ref } from 'vue'

export default {
  setup() {

      const n = ref(1), { a: __a, b: __c, d: __d = 1, e: __f = 2, ...__g } = useFoo()
const a = ref(__a);
const c = ref(__c);
const d = ref(__d);
const f = ref(__f);
const g = ref(__g);
      console.log(n.value, a.value, c.value, d.value, f.value, g.value)
      
return { n, a, c, d, f, g }
}

}"
`;

exports[`SFC compile <script setup> ref: syntax sugar should not convert non ref labels 1`] = `
"export default {
  setup() {

      foo: a = 1, b = 2, c = {
        count: 0
      }
      
return {  }
}

}"
`;

exports[`SFC compile <script setup> ref: syntax sugar using ref binding in property shorthand 1`] = `
"import { ref } from 'vue'

export default {
  setup() {

      const a = ref(1)
      const b = { a: a.value }
      function test() {
        const { a } = b
      }
      
return { a, b, test }
}

}"
`;

exports[`SFC compile <script setup> should expose top level declarations 1`] = `
"import { x } from './x'
      
export default {
  setup() {

      let a = 1
      const b = 2
      function c() {}
      class d {}
      
return { a, b, c, d, x }
}

}"
`;

exports[`SFC compile <script setup> useOptions() 1`] = `
"export default {
  props: {
    foo: String
  },
  emit: ['a', 'b'],
  setup(__props, { props, emit }) {



const bar = 1

return { props, emit, bar }
}

}"
`;

exports[`SFC compile <script setup> with TypeScript hoist type declarations 1`] = `
"import { defineComponent } from 'vue'
export interface Foo {}
        type Bar = {}
      
export default defineComponent({
  setup() {

        
return {  }
}

})"
`;

exports[`SFC compile <script setup> with TypeScript useOptions w/ runtime options 1`] = `
"import { defineComponent } from 'vue'


export default defineComponent({
  props: { foo: String },
  emits: ['a', 'b'],
  setup(__props, { props, emit }) {



return { props, emit }
}

})"
`;

exports[`SFC compile <script setup> with TypeScript useOptions w/ type / extract emits (union) 1`] = `
"import { Slots, defineComponent } from 'vue'

      
export default defineComponent({
  emits: [\\"foo\\", \\"bar\\", \\"baz\\"] as unknown as undefined,
  setup(__props, { emit }: {
  props: {},
  emit: ((e: 'foo' | 'bar') => void) | ((e: 'baz', id: number) => void),
  slots: Slots,
  attrs: Record<string, any>
}) {

      
      
return { emit }
}

})"
`;

exports[`SFC compile <script setup> with TypeScript useOptions w/ type / extract emits 1`] = `
"import { Slots, defineComponent } from 'vue'

      
export default defineComponent({
  emits: [\\"foo\\", \\"bar\\"] as unknown as undefined,
  setup(__props, { emit }: {
  props: {},
  emit: (e: 'foo' | 'bar') => void,
  slots: Slots,
  attrs: Record<string, any>
}) {

      
      
return { emit }
}

})"
`;

exports[`SFC compile <script setup> with TypeScript useOptions w/ type / extract props 1`] = `
"import { defineComponent } from 'vue'

      interface Test {}

      type Alias = number[]

      
export default defineComponent({
  props: {
    string: { type: String, required: true },
    number: { type: Number, required: true },
    boolean: { type: Boolean, required: true },
    object: { type: Object, required: true },
    objectLiteral: { type: Object, required: true },
    fn: { type: Function, required: true },
    functionRef: { type: Function, required: true },
    objectRef: { type: Object, required: true },
    array: { type: Array, required: true },
    arrayRef: { type: Array, required: true },
    tuple: { type: Array, required: true },
    set: { type: Set, required: true },
    literal: { type: String, required: true },
    optional: { type: null, required: false },
    recordRef: { type: Object, required: true },
    interface: { type: Object, required: true },
    alias: { type: Array, required: true },
    union: { type: [String, Number], required: true },
    literalUnion: { type: [String, String], required: true },
    literalUnionMixed: { type: [String, Number, Boolean], required: true },
    intersection: { type: Object, required: true }
  } as unknown as undefined,
  setup() {

      
      
return {  }
}

})"
`;