From 3850ebef08c1ea9345b0623fee7dcfe3baa5ec63 Mon Sep 17 00:00:00 2001
From: dobromir-hristov <dobromir92@gmail.com>
Date: Mon, 4 May 2020 12:06:49 +0300
Subject: [PATCH 01/10] fix: initial scoped slot work

---
 src/mount.ts                            |   8 +-
 tests/components/ComponentWithSlots.vue |  19 ++++
 tests/mountingOptions/slots.spec.ts     | 137 +++++++++++++++---------
 3 files changed, 111 insertions(+), 53 deletions(-)

diff --git a/src/mount.ts b/src/mount.ts
index ba0467f41..523fa17d6 100644
--- a/src/mount.ts
+++ b/src/mount.ts
@@ -26,6 +26,7 @@ import {
   MOUNT_PARENT_NAME
 } from './constants'
 import { stubComponents } from './stubs'
+import { compile } from '@vue/compiler-dom'
 
 type Slot = VNode | string | { render: Function }
 
@@ -103,7 +104,12 @@ export function mount(
         return acc
       }
 
-      acc[name] = () => slot
+      if (typeof slot === 'function') {
+        acc[name] = slot
+        return acc
+      }
+
+      acc[name] = () => compile(slot)
       return acc
     }, {})
 
diff --git a/tests/components/ComponentWithSlots.vue b/tests/components/ComponentWithSlots.vue
index d2c01a434..129964584 100644
--- a/tests/components/ComponentWithSlots.vue
+++ b/tests/components/ComponentWithSlots.vue
@@ -1,5 +1,24 @@
 <template>
   <div class="ComponentWithSlots">
+    <div class="default">
+      <slot />
+    </div>
+    <div class="named">
+      <slot name="named" />
+    </div>
+    <div class="withDefault">
+      <slot name="withDefault">With Default Content</slot>
+    </div>
+    <div class="scoped">
+      <slot name="scoped" v-bind="{ boolean, string, object }" />
+    </div>
+    <div class="scopedWithDefault">
+      <slot name="scopedWithDefault" v-bind="{ boolean, string, object }">
+        boolean: {{ boolean }}
+        string: {{ string }}
+        object: {{ object }}
+      </slot>
+    </div>
     <slot />
     <slot name="named" />
     <slot name="withDefault">With Default Content</slot>
diff --git a/tests/mountingOptions/slots.spec.ts b/tests/mountingOptions/slots.spec.ts
index 1f58caab2..da63585c5 100644
--- a/tests/mountingOptions/slots.spec.ts
+++ b/tests/mountingOptions/slots.spec.ts
@@ -2,75 +2,108 @@ import { defineComponent, h } from 'vue'
 
 import { mount } from '../../src'
 import WithProps from '../components/WithProps.vue'
+import ComponentWithSlots from '../components/ComponentWithSlots.vue'
 
 describe('slots', () => {
-  it('supports default slot', () => {
-    const ItemWithSlots = defineComponent({
-      name: 'ItemWithSlots',
-      render() {
-        return h('div', {}, this.$slots.default())
-      }
-    })
+  describe('normal slots', () => {
+    it('supports default slot', () => {
+      const ItemWithSlots = defineComponent({
+        name: 'ItemWithSlots',
+        render() {
+          return h('div', {}, this.$slots.default())
+        }
+      })
 
-    const wrapper = mount(ItemWithSlots, {
-      slots: {
-        default: h('span', {}, 'Default Slot')
-      }
+      const wrapper = mount(ItemWithSlots, {
+        slots: {
+          default: h('span', {}, 'Default Slot')
+        }
+      })
+
+      expect(wrapper.html()).toBe('<div><span>Default Slot</span></div>')
     })
 
-    expect(wrapper.html()).toBe('<div><span>Default Slot</span></div>')
-  })
+    it('supports named slots', () => {
+      const ItemWithNamedSlot = defineComponent({
+        render() {
+          return h('div', {}, this.$slots.foo())
+        }
+      })
 
-  it('supports named slots', () => {
-    const ItemWithNamedSlot = defineComponent({
-      render() {
-        return h('div', {}, this.$slots.foo())
-      }
-    })
+      const wrapper = mount(ItemWithNamedSlot, {
+        slots: {
+          foo: h('span', {}, 'Foo')
+        }
+      })
 
-    const wrapper = mount(ItemWithNamedSlot, {
-      slots: {
-        foo: h('span', {}, 'Foo')
-      }
+      expect(wrapper.html()).toBe('<div><span>Foo</span></div>')
     })
 
-    expect(wrapper.html()).toBe('<div><span>Foo</span></div>')
-  })
+    it('supports default and named slots together', () => {
+      const Component = defineComponent({
+        render() {
+          return h('div', {}, [
+            h('div', {}, this.$slots.foo()),
+            h('div', {}, this.$slots.default())
+          ])
+        }
+      })
 
-  it('supports default and named slots together', () => {
-    const Component = defineComponent({
-      render() {
-        return h('div', {}, [
-          h('div', {}, this.$slots.foo()),
-          h('div', {}, this.$slots.default())
-        ])
-      }
-    })
+      const wrapper = mount(Component, {
+        slots: {
+          default: 'Default',
+          foo: h('h1', {}, 'Named Slot')
+        }
+      })
 
-    const wrapper = mount(Component, {
-      slots: {
-        default: 'Default',
-        foo: h('h1', {}, 'Named Slot')
-      }
+      expect(wrapper.html()).toBe(
+        '<div><div><h1>Named Slot</h1></div><div>Default</div></div>'
+      )
     })
 
-    expect(wrapper.html()).toBe(
-      '<div><div><h1>Named Slot</h1></div><div>Default</div></div>'
-    )
+    it('supports passing a SFC', () => {
+      const wrapper = mount(
+        {
+          template: `<div><slot name="foo" msg="Hello" /></div>`
+        },
+        {
+          slots: {
+            foo: WithProps
+          }
+        }
+      )
+
+      expect(wrapper.html()).toBe('<div><p>Hello</p></div>')
+    })
   })
+  describe('scoped slots', () => {
+    it('allows providing a plain text string', () => {
+      const wrapper = mount(ComponentWithSlots, {
+        slots: {
+          scoped: 'Just a plain string'
+        }
+      })
+      expect(wrapper.find('.scoped').text()).toEqual('Just a plain string')
+    })
 
-  it('supports passing a SFC', () => {
-    const wrapper = mount(
-      {
-        template: `<div><slot name="foo" msg="Hello" /></div>`
-      },
-      {
+    it('allows passing a function that returns a render function', () => {
+      const wrapper = mount(ComponentWithSlots, {
         slots: {
-          foo: WithProps
+          scoped: (params) => h('div', {}, 'foo')
         }
-      }
-    )
+      })
 
-    expect(wrapper.html()).toBe('<div><p>Hello</p></div>')
+      expect(wrapper.find('.scoped').text()).toEqual('Just a plain string')
+    })
+
+    it('allows passing a scoped slot with params', () => {
+      const wrapper = mount(ComponentWithSlots, {
+        slots: {
+          scoped: `<div>{{ params.string }}</div>`
+        }
+      })
+
+      expect(wrapper.find('.scoped').text()).toEqual('Just a plain string')
+    })
   })
 })

From 67b96240a13b90e58443a6d47aa10583c41ea24c Mon Sep 17 00:00:00 2001
From: dobromir-hristov <dobromir92@gmail.com>
Date: Fri, 8 May 2020 11:14:55 +0300
Subject: [PATCH 02/10] feat: compile string templates to components

---
 src/mount.ts                        | 12 +++++++++---
 src/utils/compileSlots.ts           | 23 +++++++++++++++++++++++
 tests/mountingOptions/slots.spec.ts |  8 ++++----
 3 files changed, 36 insertions(+), 7 deletions(-)
 create mode 100644 src/utils/compileSlots.ts

diff --git a/src/mount.ts b/src/mount.ts
index 523fa17d6..5e79b0a82 100644
--- a/src/mount.ts
+++ b/src/mount.ts
@@ -17,6 +17,7 @@ import {
 import { config } from './config'
 import { GlobalMountOptions } from './types'
 import { mergeGlobalProperties, isString } from './utils'
+import { processSlot } from './utils/compileSlots'
 import { createWrapper, VueWrapper } from './vue-wrapper'
 import { attachEmitListener } from './emitMixin'
 import { createDataMixin } from './dataMixin'
@@ -26,9 +27,9 @@ import {
   MOUNT_PARENT_NAME
 } from './constants'
 import { stubComponents } from './stubs'
-import { compile } from '@vue/compiler-dom'
+import { parse } from '@vue/compiler-dom'
 
-type Slot = VNode | string | { render: Function }
+type Slot = VNode | string | { render: Function } | Function
 
 interface MountingOptions<Props> {
   data?: () => Record<string, unknown>
@@ -109,7 +110,12 @@ export function mount(
         return acc
       }
 
-      acc[name] = () => compile(slot)
+      if (typeof slot === 'object' && '_isVNode' in slot) {
+        acc[name] = () => slot
+        return acc
+      }
+
+      acc[name] = () => processSlot(slot)
       return acc
     }, {})
 
diff --git a/src/utils/compileSlots.ts b/src/utils/compileSlots.ts
new file mode 100644
index 000000000..2e4260c47
--- /dev/null
+++ b/src/utils/compileSlots.ts
@@ -0,0 +1,23 @@
+import { compile } from '@vue/compiler-dom'
+
+export function processSlot(template) {
+  const Vue = require('vue')
+
+  const { code } = compile(
+    `<SlotWrapper v-bind="$attrs">${template}</SlotWrapper>`,
+    {
+      mode: 'function',
+      prefixIdentifiers: true
+    }
+  )
+  return {
+    render: eval(`(() => {${code}})()`),
+    components: {
+      SlotWrapper: {
+        setup(props, { slots }) {
+          return () => slots.default(props)
+        }
+      }
+    }
+  }
+}
diff --git a/tests/mountingOptions/slots.spec.ts b/tests/mountingOptions/slots.spec.ts
index da63585c5..c95b1e9b6 100644
--- a/tests/mountingOptions/slots.spec.ts
+++ b/tests/mountingOptions/slots.spec.ts
@@ -39,11 +39,11 @@ describe('slots', () => {
       expect(wrapper.html()).toBe('<div><span>Foo</span></div>')
     })
 
-    it('supports default and named slots together', () => {
+    it.only('supports default and named slots together', () => {
       const Component = defineComponent({
         render() {
           return h('div', {}, [
-            h('div', {}, this.$slots.foo()),
+            // h('div', {}, this.$slots.foo()),
             h('div', {}, this.$slots.default())
           ])
         }
@@ -51,8 +51,8 @@ describe('slots', () => {
 
       const wrapper = mount(Component, {
         slots: {
-          default: 'Default',
-          foo: h('h1', {}, 'Named Slot')
+          default: 'Default'
+          // foo: h('h1', {}, 'Named Slot')
         }
       })
 

From 722fa06b60f4039cbab4a1f740643d690fb8af4d Mon Sep 17 00:00:00 2001
From: Rahul Kadyan <hi@znck.me>
Date: Fri, 8 May 2020 19:59:59 +0530
Subject: [PATCH 03/10] compile slot partial template

---
 src/mount.ts                        |  2 +-
 src/utils/compileSlots.ts           | 22 ++++++++++++++++------
 tests/mountingOptions/slots.spec.ts |  4 ++--
 3 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/src/mount.ts b/src/mount.ts
index 5e79b0a82..a2296d961 100644
--- a/src/mount.ts
+++ b/src/mount.ts
@@ -115,7 +115,7 @@ export function mount(
         return acc
       }
 
-      acc[name] = () => processSlot(slot)
+      acc[name] = (props) => h(processSlot(slot), props)
       return acc
     }, {})
 
diff --git a/src/utils/compileSlots.ts b/src/utils/compileSlots.ts
index 2e4260c47..223e7d29b 100644
--- a/src/utils/compileSlots.ts
+++ b/src/utils/compileSlots.ts
@@ -1,8 +1,6 @@
 import { compile } from '@vue/compiler-dom'
 
-export function processSlot(template) {
-  const Vue = require('vue')
-
+export function processSlot(template, Vue = require('vue')) {
   const { code } = compile(
     `<SlotWrapper v-bind="$attrs">${template}</SlotWrapper>`,
     {
@@ -10,12 +8,24 @@ export function processSlot(template) {
       prefixIdentifiers: true
     }
   )
+  const createRenderFunction = new Function('Vue', `'use strict';\n${code}`)
+
   return {
-    render: eval(`(() => {${code}})()`),
+    inheritAttrs: false,
+    render: createRenderFunction(Vue),
     components: {
       SlotWrapper: {
-        setup(props, { slots }) {
-          return () => slots.default(props)
+        inheritAttrs: false,
+        setup(_, { slots, attrs }) {
+          return () => {
+            const names = Object.keys(slots)
+            if (names.length === 0) {
+              return []
+            } else {
+              const slotName = names[0]
+              return slots[slotName](attrs)
+            }
+          }
         }
       }
     }
diff --git a/tests/mountingOptions/slots.spec.ts b/tests/mountingOptions/slots.spec.ts
index c95b1e9b6..d38b577b2 100644
--- a/tests/mountingOptions/slots.spec.ts
+++ b/tests/mountingOptions/slots.spec.ts
@@ -39,7 +39,7 @@ describe('slots', () => {
       expect(wrapper.html()).toBe('<div><span>Foo</span></div>')
     })
 
-    it.only('supports default and named slots together', () => {
+    it('supports default and named slots together', () => {
       const Component = defineComponent({
         render() {
           return h('div', {}, [
@@ -99,7 +99,7 @@ describe('slots', () => {
     it('allows passing a scoped slot with params', () => {
       const wrapper = mount(ComponentWithSlots, {
         slots: {
-          scoped: `<div>{{ params.string }}</div>`
+          scoped: `<template #scoped="params"><div>Just a plain {{ params.string }}</div></template>`
         }
       })
 

From a524398357a1e2efdf24b18de1b97b76a3728c89 Mon Sep 17 00:00:00 2001
From: dobromir-hristov <dobromir92@gmail.com>
Date: Sat, 9 May 2020 09:36:39 +0300
Subject: [PATCH 04/10] feat: allow passing scoped slot templates without
 wrapping template tag.

Improve tests
---
 src/mount.ts                        |   1 +
 src/utils/compileSlots.ts           |   9 +-
 tests/mountingOptions/slots.spec.ts | 136 +++++++++++++++++-----------
 3 files changed, 94 insertions(+), 52 deletions(-)

diff --git a/src/mount.ts b/src/mount.ts
index a2296d961..34eb29feb 100644
--- a/src/mount.ts
+++ b/src/mount.ts
@@ -115,6 +115,7 @@ export function mount(
         return acc
       }
 
+      // slot is most probably a scoped slot string or a plain string
       acc[name] = (props) => h(processSlot(slot), props)
       return acc
     }, {})
diff --git a/src/utils/compileSlots.ts b/src/utils/compileSlots.ts
index 223e7d29b..dda164409 100644
--- a/src/utils/compileSlots.ts
+++ b/src/utils/compileSlots.ts
@@ -1,6 +1,13 @@
 import { compile } from '@vue/compiler-dom'
 
-export function processSlot(template, Vue = require('vue')) {
+export function processSlot(template: string, Vue = require('vue')) {
+  const hasWrappingTemplate = template.startsWith('<template')
+
+  // allow content without `template` tag, for easier testing
+  if (!hasWrappingTemplate) {
+    template = `<template #default="params">${template}</template>`
+  }
+
   const { code } = compile(
     `<SlotWrapper v-bind="$attrs">${template}</SlotWrapper>`,
     {
diff --git a/tests/mountingOptions/slots.spec.ts b/tests/mountingOptions/slots.spec.ts
index d38b577b2..f96f06c58 100644
--- a/tests/mountingOptions/slots.spec.ts
+++ b/tests/mountingOptions/slots.spec.ts
@@ -1,81 +1,83 @@
-import { defineComponent, h } from 'vue'
+import { h } from 'vue'
 
 import { mount } from '../../src'
-import WithProps from '../components/WithProps.vue'
+import Hello from '../components/Hello.vue'
 import ComponentWithSlots from '../components/ComponentWithSlots.vue'
 
 describe('slots', () => {
   describe('normal slots', () => {
-    it('supports default slot', () => {
-      const ItemWithSlots = defineComponent({
-        name: 'ItemWithSlots',
-        render() {
-          return h('div', {}, this.$slots.default())
-        }
-      })
-
-      const wrapper = mount(ItemWithSlots, {
+    it('supports providing a plain string text in slot', () => {
+      const defaultString = 'Rendered in Default'
+      let namedString = 'Rendered in Named'
+      const wrapper = mount(ComponentWithSlots, {
         slots: {
-          default: h('span', {}, 'Default Slot')
+          default: defaultString,
+          named: namedString
         }
       })
-
-      expect(wrapper.html()).toBe('<div><span>Default Slot</span></div>')
+      expect(wrapper.find('.default').text()).toBe(defaultString)
+      expect(wrapper.find('.named').text()).toBe(namedString)
     })
 
-    it('supports named slots', () => {
-      const ItemWithNamedSlot = defineComponent({
-        render() {
-          return h('div', {}, this.$slots.foo())
-        }
-      })
+    it('supports providing an html string into a slot', () => {
+      const defaultSlot = '<div><p class="defaultNested">Content</p></div>'
+      const namedSlot = '<div><p class="namedNested">Content</p></div>'
 
-      const wrapper = mount(ItemWithNamedSlot, {
+      const wrapper = mount(ComponentWithSlots, {
         slots: {
-          foo: h('span', {}, 'Foo')
+          default: defaultSlot,
+          named: namedSlot
         }
       })
 
-      expect(wrapper.html()).toBe('<div><span>Foo</span></div>')
+      expect(wrapper.find('.defaultNested').exists()).toBe(true)
+      expect(wrapper.find('.namedNested').exists()).toBe(true)
     })
 
-    it('supports default and named slots together', () => {
-      const Component = defineComponent({
-        render() {
-          return h('div', {}, [
-            // h('div', {}, this.$slots.foo()),
-            h('div', {}, this.$slots.default())
-          ])
+    it('supports providing a render function to slot', () => {
+      const wrapper = mount(ComponentWithSlots, {
+        slots: {
+          default: h('span', {}, 'Default'),
+          named: h('span', {}, 'Named')
         }
       })
 
-      const wrapper = mount(Component, {
+      expect(wrapper.find('.default').html()).toEqual(
+        '<div class="default"><span>Default</span></div>'
+      )
+      expect(wrapper.find('.named').html()).toEqual(
+        '<div class="named"><span>Named</span></div>'
+      )
+    })
+
+    it('does not render slots that do not exist', () => {
+      const wrapper = mount(ComponentWithSlots, {
         slots: {
-          default: 'Default'
-          // foo: h('h1', {}, 'Named Slot')
+          notExisting: h('span', {}, 'NotExistingText')
         }
       })
 
-      expect(wrapper.html()).toBe(
-        '<div><div><h1>Named Slot</h1></div><div>Default</div></div>'
-      )
+      expect(wrapper.text()).not.toContain('NotExistingText')
     })
 
     it('supports passing a SFC', () => {
-      const wrapper = mount(
-        {
-          template: `<div><slot name="foo" msg="Hello" /></div>`
-        },
-        {
-          slots: {
-            foo: WithProps
-          }
+      const wrapper = mount(ComponentWithSlots, {
+        slots: {
+          named: Hello
         }
-      )
+      })
 
-      expect(wrapper.html()).toBe('<div><p>Hello</p></div>')
+      expect(wrapper.find('.named').html()).toBe(
+        '' +
+          '<div class="named">' +
+          '<div id="root">' +
+          '<div id="msg"></div>' +
+          '</div>' +
+          '</div>'
+      )
     })
   })
+
   describe('scoped slots', () => {
     it('allows providing a plain text string', () => {
       const wrapper = mount(ComponentWithSlots, {
@@ -89,21 +91,53 @@ describe('slots', () => {
     it('allows passing a function that returns a render function', () => {
       const wrapper = mount(ComponentWithSlots, {
         slots: {
-          scoped: (params) => h('div', {}, 'foo')
+          scoped: (params) => h('div', {}, JSON.stringify(params))
         }
       })
 
-      expect(wrapper.find('.scoped').text()).toEqual('Just a plain string')
+      expect(wrapper.find('.scoped').text()).toEqual(
+        '{"boolean":true,"string":"string","object":{"foo":"foo"}}'
+      )
     })
 
-    it('allows passing a scoped slot with params', () => {
+    it('allows passing a scoped slot via string with no destructuring using the # syntax', () => {
       const wrapper = mount(ComponentWithSlots, {
         slots: {
-          scoped: `<template #scoped="params"><div>Just a plain {{ params.string }}</div></template>`
+          scoped: `<template #scoped="params"><div>Just a plain {{ params.boolean }} {{ params.string }}</div></template>`
         }
       })
 
-      expect(wrapper.find('.scoped').text()).toEqual('Just a plain string')
+      expect(wrapper.find('.scoped').text()).toEqual('Just a plain true string')
+    })
+
+    it('allows passing a scoped slot via a string with destructuring using the # syntax', () => {
+      const wrapper = mount(ComponentWithSlots, {
+        slots: {
+          scoped: `<template #scoped="{string, boolean}"><div>Just a plain {{ boolean }} {{ string }}</div></template>`
+        }
+      })
+
+      expect(wrapper.find('.scoped').text()).toEqual('Just a plain true string')
+    })
+
+    it('allows passing a scoped slot via string with no destructuring using the v-slot syntax ', () => {
+      const wrapper = mount(ComponentWithSlots, {
+        slots: {
+          scoped: `<template v-slot:scoped="params"><div>Just a plain {{ params.boolean }} {{ params.string }}</div></template>`
+        }
+      })
+
+      expect(wrapper.find('.scoped').text()).toEqual('Just a plain true string')
+    })
+
+    it('allows passing a scoped slot via string with no destructuring without template tag', () => {
+      const wrapper = mount(ComponentWithSlots, {
+        slots: {
+          scoped: `<div>Just a plain {{ params.boolean }} {{ params.string }}</div>`
+        }
+      })
+
+      expect(wrapper.find('.scoped').text()).toEqual('Just a plain true string')
     })
   })
 })

From 08c9d70ad0e7d505dcfed57d116807e1c5cf18f9 Mon Sep 17 00:00:00 2001
From: dobromir-hristov <dobromir92@gmail.com>
Date: Sat, 9 May 2020 09:49:30 +0300
Subject: [PATCH 05/10] chore: add extra test

---
 tests/mountingOptions/slots.spec.ts | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/tests/mountingOptions/slots.spec.ts b/tests/mountingOptions/slots.spec.ts
index f96f06c58..ba8019881 100644
--- a/tests/mountingOptions/slots.spec.ts
+++ b/tests/mountingOptions/slots.spec.ts
@@ -100,6 +100,26 @@ describe('slots', () => {
       )
     })
 
+    it('allows passing a function to store variables for assertion', () => {
+      let assertParams
+
+      const wrapper = mount(ComponentWithSlots, {
+        slots: {
+          scoped: (params) => {
+            assertParams = params
+            // always return something
+            return 'foo'
+          }
+        }
+      })
+
+      expect(assertParams).toEqual({
+        boolean: true,
+        string: 'string',
+        object: { foo: 'foo' }
+      })
+    })
+
     it('allows passing a scoped slot via string with no destructuring using the # syntax', () => {
       const wrapper = mount(ComponentWithSlots, {
         slots: {

From 5ef57f9301a52bf267efd6336d1aa7423d4ddc97 Mon Sep 17 00:00:00 2001
From: dobromir-hristov <dobromir92@gmail.com>
Date: Sat, 9 May 2020 09:52:27 +0300
Subject: [PATCH 06/10] chore: remove unnecessary param type

---
 src/utils/compileSlots.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/utils/compileSlots.ts b/src/utils/compileSlots.ts
index dda164409..142b41dd0 100644
--- a/src/utils/compileSlots.ts
+++ b/src/utils/compileSlots.ts
@@ -1,6 +1,6 @@
 import { compile } from '@vue/compiler-dom'
 
-export function processSlot(template: string, Vue = require('vue')) {
+export function processSlot(template, Vue = require('vue')) {
   const hasWrappingTemplate = template.startsWith('<template')
 
   // allow content without `template` tag, for easier testing

From 5fd19d5ece61867f3839f1c2bbaa1ca390d17133 Mon Sep 17 00:00:00 2001
From: dobromir-hristov <dobromir92@gmail.com>
Date: Sat, 9 May 2020 09:56:55 +0300
Subject: [PATCH 07/10] chore: cleanup

---
 src/mount.ts              | 2 +-
 src/utils/compileSlots.ts | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/mount.ts b/src/mount.ts
index 34eb29feb..a9ac7fd60 100644
--- a/src/mount.ts
+++ b/src/mount.ts
@@ -116,7 +116,7 @@ export function mount(
       }
 
       // slot is most probably a scoped slot string or a plain string
-      acc[name] = (props) => h(processSlot(slot), props)
+      acc[name] = (props) => h(processSlot(slot as string), props)
       return acc
     }, {})
 
diff --git a/src/utils/compileSlots.ts b/src/utils/compileSlots.ts
index 142b41dd0..c4bc97bc9 100644
--- a/src/utils/compileSlots.ts
+++ b/src/utils/compileSlots.ts
@@ -1,7 +1,7 @@
 import { compile } from '@vue/compiler-dom'
 
-export function processSlot(template, Vue = require('vue')) {
-  const hasWrappingTemplate = template.startsWith('<template')
+export function processSlot(template = '', Vue = require('vue')) {
+  const hasWrappingTemplate = template && template.startsWith('<template')
 
   // allow content without `template` tag, for easier testing
   if (!hasWrappingTemplate) {

From 0ab237bb69cc5bbaac484a2c1419a2c089508070 Mon Sep 17 00:00:00 2001
From: dobromir-hristov <dobromir92@gmail.com>
Date: Sat, 9 May 2020 10:02:02 +0300
Subject: [PATCH 08/10] chore: ensure slot is a string before compiling

---
 src/mount.ts | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/mount.ts b/src/mount.ts
index a9ac7fd60..3f0f8e6f6 100644
--- a/src/mount.ts
+++ b/src/mount.ts
@@ -115,9 +115,11 @@ export function mount(
         return acc
       }
 
-      // slot is most probably a scoped slot string or a plain string
-      acc[name] = (props) => h(processSlot(slot as string), props)
-      return acc
+      if (typeof slot === 'string') {
+        // slot is most probably a scoped slot string or a plain string
+        acc[name] = (props) => h(processSlot(slot), props)
+        return acc
+      }
     }, {})
 
   // override component data with mounting options data

From 97623ef7d25a19420f3e919fa7584f4bc1d0dd2f Mon Sep 17 00:00:00 2001
From: dobromir-hristov <dobromir92@gmail.com>
Date: Sat, 9 May 2020 10:08:23 +0300
Subject: [PATCH 09/10] chore: fix render func test

---
 src/mount.ts                        | 2 +-
 tests/mountingOptions/slots.spec.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/mount.ts b/src/mount.ts
index 3f0f8e6f6..3d6d0aca6 100644
--- a/src/mount.ts
+++ b/src/mount.ts
@@ -110,7 +110,7 @@ export function mount(
         return acc
       }
 
-      if (typeof slot === 'object' && '_isVNode' in slot) {
+      if (typeof slot === 'object') {
         acc[name] = () => slot
         return acc
       }
diff --git a/tests/mountingOptions/slots.spec.ts b/tests/mountingOptions/slots.spec.ts
index ba8019881..b052383f6 100644
--- a/tests/mountingOptions/slots.spec.ts
+++ b/tests/mountingOptions/slots.spec.ts
@@ -53,7 +53,7 @@ describe('slots', () => {
     it('does not render slots that do not exist', () => {
       const wrapper = mount(ComponentWithSlots, {
         slots: {
-          notExisting: h('span', {}, 'NotExistingText')
+          notExisting: () => h('span', {}, 'NotExistingText')
         }
       })
 

From 3e195a38361d1443889bd293d4854b4b35808186 Mon Sep 17 00:00:00 2001
From: Lachlan Miller <lachlan.miller.1990@outlook.com>
Date: Sun, 10 May 2020 11:46:21 +1000
Subject: [PATCH 10/10] chore: specify compiler-dom as external

---
 rollup.config.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/rollup.config.js b/rollup.config.js
index a330c22a6..7e4cd409b 100644
--- a/rollup.config.js
+++ b/rollup.config.js
@@ -25,6 +25,7 @@ function createEntry(options) {
     input,
     external: [
       'vue',
+      '@vue/compiler-dom',
       'lodash/mergeWith',
       'lodash/isString'
     ],
@@ -41,6 +42,7 @@ function createEntry(options) {
       format,
       globals: {
         vue: 'Vue',
+        '@vue/compiler-dom': 'VueCompilerDOM',
         'lodash/mergeWith': '_.mergeWith',
         'lodash/isString': '_.isString',
       }