reactivityTransform.spec.ts.snap

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

exports[`$ unwrapping 1`] = `
"
    import { ref, shallowRef } from 'vue'
    let foo = ref()
    export let a = ref(1)
    let b = shallowRef({
      count: 0
    })
    let c = () => {}
    let d
    label: var e = ref()
    "
`;

exports[`$$ 1`] = `
"import { ref as _ref } from 'vue'

    let a = _ref(1)
    const b = a
    const c = { a }
    callExternal(a)
    "
`;

exports[`$$ with some edge cases 1`] = `
"import { ref as _ref } from 'vue'

    /* 2 */ count /* 2 */
    ;(   count /* 2 */, /**/ a   )
    ;   (count /* 2 */, /**/ a /**/   )
    {
      a:(count,a)
    }
    ;((count) + 1)
    ;([count])
    count
    console.log(a)
    ;(a,b)
    ;(a++,b)
    count = ( a++ ,b)
    count = ()=>(a++,b)
    let r1 = _ref(a, (a++,b))
    let r2 = { a:(a++,b),b:a }
    switch(c){
      case d:
        a
        ;(h,f)
        break
    }
    ((count++,count,(count,a)))
    "
`;

exports[`$computed declaration 1`] = `
"import { computed as _computed } from 'vue'

    let a = _computed(() => 1)
    "
`;

exports[`$ref & $shallowRef declarations 1`] = `
"import { ref as _ref, shallowRef as _shallowRef } from 'vue'

    let foo = _ref()
    export let a = _ref(1)
    let b = _shallowRef({
      count: 0
    })
    let c = () => {}
    let d
    label: var e = _ref()
    "
`;

exports[`accessing ref binding 1`] = `
"import { ref as _ref } from 'vue'

    let a = _ref(1)
    console.log(a.value)
    function get() {
      return a.value + 1
    }
    "
`;

exports[`array destructure 1`] = `
"import { ref as _ref, toRef as _toRef } from 'vue'

    let n = _ref(1), __$temp_1 = useFoo(),
  a = _toRef(__$temp_1, 0),
  b = _toRef(__$temp_1, 1, 1);
    console.log(n.value, a.value, b.value)
    "
`;

exports[`handle TS casting syntax 1`] = `
"import { ref as _ref } from 'vue'

      let a = _ref(1)
      console.log(a.value!)
      console.log(a.value! + 1)
      console.log(a.value as number)
      console.log((a.value as number) + 1)
      console.log(<number>a.value)
      console.log(<number>a.value + 1)
      console.log(a.value! + (a.value as number))
      console.log(a.value! + <number>a.value)
      console.log((a.value as number) + <number>a.value)
      "
`;

exports[`macro import alias and removal 1`] = `
"import { ref as _ref, toRef as _toRef } from 'vue'

    

    let a = _ref(1)
    const __$temp_1 = useMouse(),
  x = _toRef(__$temp_1, 'x'),
  y = _toRef(__$temp_1, 'y');
    "
`;

exports[`mixing $ref & $computed declarations 1`] = `
"import { ref as _ref, computed as _computed } from 'vue'

    let a = _ref(1), b = _computed(() => a.value + 1)
    "
`;

exports[`multi $ref declarations 1`] = `
"import { ref as _ref } from 'vue'

    let a = _ref(1), b = _ref(2), c = _ref({
      count: 0
    })
    "
`;

exports[`mutating ref binding 1`] = `
"import { ref as _ref } from 'vue'

    let a = _ref(1)
    let b = _ref({ count: 0 })
    function inc() {
      a.value++
      a.value = a.value + 1
      b.value.count++
      b.value.count = b.value.count + 1
      ;({ a: a.value } = { a: 2 })
      ;[a.value] = [1]
    }
    "
`;

exports[`nested destructure 1`] = `
"import { toRef as _toRef } from 'vue'

    let __$temp_1 = useFoo(),
  b = _toRef(__$temp_1[0].a, 'b');
    let __$temp_2 = useBar(),
  d = _toRef(__$temp_2.c, 0),
  e = _toRef(__$temp_2.c, 1);
    console.log(b.value, d.value, e.value)
    "
`;

exports[`nested scopes 1`] = `
"import { ref as _ref } from 'vue'

    let a = _ref(0)
    let b = _ref(0)
    let c = 0

    a.value++ // outer a
    b.value++ // outer b
    c++ // outer c

    let bar = _ref(0)
    bar.value++ // outer bar

    function foo({ a }) {
      a++ // inner a
      b.value++ // inner b
      let c = _ref(0)
      c.value++ // inner c
      let d = _ref(0)

      function bar(c) {
        c++ // nested c
        d.value++ // nested d
      }
      bar() // inner bar

      if (true) {
        let a = _ref(0)
        a.value++ // if block a
      }

      return { a, b, c, d }
    }
    "
`;

exports[`object destructure 1`] = `
"import { ref as _ref, toRef as _toRef } from 'vue'

    let n = _ref(1), __$temp_1 = useFoo(),
  a = _toRef(__$temp_1, 'a'),
  c = _toRef(__$temp_1, 'b'),
  d = _toRef(__$temp_1, 'd', 1),
  f = _toRef(__$temp_1, 'e', 2),
  h = _toRef(__$temp_1, g);
    let __$temp_2 = useSomething(() => 1),
  foo = _toRef(__$temp_2, 'foo');;
    console.log(n.value, a.value, c.value, d.value, f.value, h.value, foo.value)
    "
`;

exports[`object destructure w/ mid-path default values 1`] = `
"import { toRef as _toRef } from 'vue'

    const __$temp_1 = useFoo(),
  b = _toRef((__$temp_1.a || { b: 123 }), 'b');
    console.log(b.value)
  "
`;

exports[`should not overwrite current scope 1`] = `
"
    const fn = () => {
      const $ = () => 'foo'
      const $ref = () => 'bar'
      const $$ = () => 'baz'
      console.log($())
      console.log($ref())
      console.log($$())
    }
    "
`;

exports[`should not overwrite importing 1`] = `
"
    import { $, $$ } from './foo'
    $('foo')
    $$('bar')
    "
`;

exports[`should not rewrite scope variable 1`] = `
"import { ref as _ref } from 'vue'


      let a = _ref(1)
      let b = _ref(1)
      let d = _ref(1)
      const e = 1
      function test() {
        const a = 2
        console.log(a)
        console.log(b.value)
        let c = { c: 3 }
        console.log(c)
        console.log(d.value)
        console.log(e)
      }
      let err = _ref(null)
      try {
      } catch (err) {
        console.log(err)
      }
    "
`;

exports[`should not rewrite type identifiers 1`] = `
"import { ref as _ref } from 'vue'
const props = defineProps<{msg: string; ids?: string[]}>()
        let ids = _ref([])"
`;

exports[`using ref binding in property shorthand 1`] = `
"import { ref as _ref } from 'vue'

    let a = _ref(1)
    const b = { a: a.value }
    function test() {
      const { a } = b
    }
    "
`;