chore(release): add dist files

Author: eddyerburgh

packages/server-test-utils/dist/vue-server-test-utils.js

@@ -10,39 +10,56 @@ var cheerio = _interopDefault(require('cheerio'));
 
 // 
 
-function startsWithTag (str) {
-  return str && str.trim()[0] === '<'
+function createVNodes (
+  vm,
+  slotValue
+) {
+  var el = vueTemplateCompiler.compileToFunctions(("<div>" + slotValue + "</div>"));
+  var _staticRenderFns = vm._renderProxy.$options.staticRenderFns;
+  // version < 2.5
+  if (!vm._renderProxy._staticTrees) {
+    vm._renderProxy._staticTrees = [];
+  }
+  vm._renderProxy.$options.staticRenderFns = el.staticRenderFns;
+  var vnode = el.render.call(vm._renderProxy, vm.$createElement);
+  vm._renderProxy.$options.staticRenderFns = _staticRenderFns;
+  return vnode.children
 }
 
 function createVNodesForSlot (
-  h,
+  vm,
   slotValue,
   name
 ) {
-  if (typeof slotValue === 'string' && !startsWithTag(slotValue)) {
-    return slotValue
+  var vnode;
+  if (typeof slotValue === 'string') {
+    var vnodes = createVNodes(vm, slotValue);
+    vnode = vnodes[0];
+  } else {
+    vnode = vm.$createElement(slotValue);
+  }
+  if (vnode.data) {
+    vnode.data.slot = name;
+  } else {
+    vnode.data = { slot: name };
   }
-
-  var el =
-    typeof slotValue === 'string' ? vueTemplateCompiler.compileToFunctions(slotValue) : slotValue;
-
-  var vnode = h(el);
-  vnode.data.slot = name;
   return vnode
 }
 
 function createSlotVNodes (
-  h,
+  vm,
   slots
 ) {
   return Object.keys(slots).reduce(function (acc, key) {
     var content = slots[key];
     if (Array.isArray(content)) {
-      var nodes = content.map(function (slotDef) { return createVNodesForSlot(h, slotDef, key); });
+      var nodes = content.map(
+        function (slotDef) { return createVNodesForSlot(vm, slotDef, key); }
+      );
       return acc.concat(nodes)
     }
 
-    return acc.concat(createVNodesForSlot(h, content, key))
+    return acc.concat(createVNodesForSlot(vm, content, key))
   }, [])
 }
 
@@ -82,7 +99,10 @@ var vueVersion = Number(
 
 // 
 
-function addMocks (mockedProperties, Vue$$1) {
+function addMocks (
+  mockedProperties,
+  Vue$$1
+) {
   Object.keys(mockedProperties).forEach(function (key) {
     try {
       Vue$$1.prototype[key] = mockedProperties[key];
@@ -127,6 +147,26 @@ function addEventLogger (vue) {
 
 // 
 
+function isVueComponent (component) {
+  if (typeof component === 'function' && component.options) {
+    return true
+  }
+
+  if (component === null || typeof component !== 'object') {
+    return false
+  }
+
+  if (component.extends || component._Ctor) {
+    return true
+  }
+
+  if (typeof component.template === 'string') {
+    return true
+  }
+
+  return typeof component.render === 'function'
+}
+
 function componentNeedsCompiling (component) {
   return (
     component &&
@@ -136,13 +176,20 @@ function componentNeedsCompiling (component) {
   )
 }
 
-function templateContainsComponent (template, name) {
+function templateContainsComponent (
+  template,
+  name
+) {
   return [capitalize, camelize, hyphenate].some(function (format) {
     var re = new RegExp(("<" + (format(name)) + "\\s*(\\s|>|(/>))"), 'g');
     return re.test(template)
   })
 }
 
+function isPlainObject (obj) {
+  return Object.prototype.toString.call(obj) === '[object Object]'
+}
+
 // 
 
 function compileTemplate (component) {
@@ -170,36 +217,46 @@ function compileTemplate (component) {
 
 // 
 
-function isVueComponent$1 (comp) {
-  return comp && (comp.render || comp.template || comp.options)
+function isVueComponentStub (comp) {
+  return comp && comp.template || isVueComponent(comp)
 }
 
 function isValidStub (stub) {
   return (
     (!!stub && typeof stub === 'string') ||
     stub === true ||
-    isVueComponent$1(stub)
+    isVueComponentStub(stub)
   )
 }
 
-function getCoreProperties (component) {
+function resolveComponent (obj, component) {
+  return obj[component] ||
+    obj[hyphenate(component)] ||
+    obj[camelize(component)] ||
+    obj[capitalize(camelize(component))] ||
+    obj[capitalize(component)] ||
+    {}
+}
+
+function getCoreProperties (componentOptions) {
   return {
-    attrs: component.attrs,
-    name: component.name,
-    on: component.on,
-    key: component.key,
-    ref: component.ref,
-    props: component.props,
-    domProps: component.domProps,
-    class: component.class,
-    staticClass: component.staticClass,
-    staticStyle: component.staticStyle,
-    style: component.style,
-    normalizedStyle: component.normalizedStyle,
-    nativeOn: component.nativeOn,
-    functional: component.functional
+    attrs: componentOptions.attrs,
+    name: componentOptions.name,
+    on: componentOptions.on,
+    key: componentOptions.key,
+    ref: componentOptions.ref,
+    props: componentOptions.props,
+    domProps: componentOptions.domProps,
+    class: componentOptions.class,
+    staticClass: componentOptions.staticClass,
+    staticStyle: componentOptions.staticStyle,
+    style: componentOptions.style,
+    normalizedStyle: componentOptions.normalizedStyle,
+    nativeOn: componentOptions.nativeOn,
+    functional: componentOptions.functional
   }
 }
+
 function createStubFromString (
   templateString,
   originalComponent,
@@ -217,21 +274,34 @@ function createStubFromString (
     throwError('options.stub cannot contain a circular reference');
   }
 
-  return Object.assign({}, getCoreProperties(originalComponent),
+  var componentOptions = typeof originalComponent === 'function'
+    ? originalComponent.extendOptions
+    : originalComponent;
+
+  return Object.assign({}, getCoreProperties(componentOptions),
     vueTemplateCompiler.compileToFunctions(templateString))
 }
 
-function createBlankStub (originalComponent) {
-  var name = (originalComponent.name) + "-stub";
+function createBlankStub (
+  originalComponent,
+  name
+) {
+  var componentOptions = typeof originalComponent === 'function'
+    ? originalComponent.extendOptions
+    : originalComponent;
+  var tagName = name + "-stub";
 
   // ignoreElements does not exist in Vue 2.0.x
   if (Vue.config.ignoredElements) {
-    Vue.config.ignoredElements.push(name);
+    Vue.config.ignoredElements.push(tagName);
   }
 
-  return Object.assign({}, getCoreProperties(originalComponent),
+  return Object.assign({}, getCoreProperties(componentOptions),
     {render: function render (h) {
-      return h(name)
+      return h(
+        tagName,
+        !componentOptions.functional && this.$slots.default
+      )
     }})
 }
 
@@ -254,78 +324,98 @@ function createComponentStubs (
       if (typeof stub !== 'string') {
         throwError("each item in an options.stubs array must be a " + "string");
       }
-      components[stub] = createBlankStub({ name: stub });
+      var component = resolveComponent(originalComponents, stub);
+
+      components[stub] = createBlankStub(component, stub);
     });
   } else {
-    Object.keys(stubs).forEach(function (stub) {
-      if (stubs[stub] === false) {
+    var stubsObject = (stubs);
+    Object.keys(stubsObject).forEach(function (stubName) {
+      var stub = stubsObject[stubName];
+      if (stub === false) {
         return
       }
-      if (!isValidStub(stubs[stub])) {
+
+      if (!isValidStub(stub)) {
         throwError(
           "options.stub values must be passed a string or " + "component"
         );
       }
-      if (stubs[stub] === true) {
-        components[stub] = createBlankStub({ name: stub });
+
+      if (stub === true) {
+        var component = resolveComponent(originalComponents, stubName);
+        components[stubName] = createBlankStub(component, stubName);
         return
       }
 
-      if (componentNeedsCompiling(stubs[stub])) {
-        compileTemplate(stubs[stub]);
+      if (typeof stub !== 'string' && componentNeedsCompiling(stub)) {
+        compileTemplate(stub);
       }
 
-      if (originalComponents[stub]) {
+      if (originalComponents[stubName]) {
         // Remove cached constructor
-        delete originalComponents[stub]._Ctor;
-        if (typeof stubs[stub] === 'string') {
-          components[stub] = createStubFromString(
-            stubs[stub],
-            originalComponents[stub],
-            stub
+        delete originalComponents[stubName]._Ctor;
+        if (typeof stub === 'string') {
+          components[stubName] = createStubFromString(
+            stub,
+            originalComponents[stubName],
+            stubName
           );
         } else {
-          components[stub] = Object.assign({}, stubs[stub],
-            {name: originalComponents[stub].name});
+          var stubObject = (stub);
+          components[stubName] = Object.assign({}, stubObject,
+            {name: originalComponents[stubName].name});
         }
       } else {
-        if (typeof stubs[stub] === 'string') {
+        if (typeof stub === 'string') {
           if (!vueTemplateCompiler.compileToFunctions) {
             throwError(
               "vueTemplateCompiler is undefined, you must pass " +
                 "precompiled components if vue-template-compiler is " +
                 "undefined"
             );
           }
-          components[stub] = Object.assign({}, vueTemplateCompiler.compileToFunctions(stubs[stub]));
+          components[stubName] = Object.assign({}, vueTemplateCompiler.compileToFunctions(stub));
         } else {
-          components[stub] = Object.assign({}, stubs[stub]);
+          var stubObject$1 = (stub);
+          components[stubName] = Object.assign({}, stubObject$1);
         }
       }
     });
   }
   return components
 }
 
-function deleteMountingOptions (options) {
-  delete options.attachToDocument;
-  delete options.mocks;
-  delete options.slots;
-  delete options.localVue;
-  delete options.stubs;
-  delete options.context;
-  delete options.clone;
-  delete options.attrs;
-  delete options.listeners;
-  delete options.propsData;
+// 
+
+var MOUNTING_OPTIONS = [
+  'attachToDocument',
+  'mocks',
+  'slots',
+  'localVue',
+  'stubs',
+  'context',
+  'clone',
+  'attrs',
+  'listeners',
+  'propsData'
+];
+
+function extractInstanceOptions (
+  options
+) {
+  var instanceOptions = Object.assign({}, options);
+  MOUNTING_OPTIONS.forEach(function (mountingOption) {
+    delete instanceOptions[mountingOption];
+  });
+  return instanceOptions
 }
 
 // 
 
 function isValidSlot (slot) {
   return (
-    Array.isArray(slot) ||
-    (slot !== null && typeof slot === 'object') ||
+    isVueComponent(slot) ||
     typeof slot === 'string'
   )
 }
@@ -342,25 +432,17 @@ function requiresTemplateCompiler (slot) {
 
 function validateSlots (slots) {
   Object.keys(slots).forEach(function (key) {
-    if (!isValidSlot(slots[key])) {
-      throwError(
-        "slots[key] must be a Component, string or an array " + "of Components"
-      );
-    }
-
-    requiresTemplateCompiler(slots[key]);
+    var slot = Array.isArray(slots[key]) ? slots[key] : [slots[key]];
 
-    if (Array.isArray(slots[key])) {
-      slots[key].forEach(function (slotValue) {
-        if (!isValidSlot(slotValue)) {
-          throwError(
-            "slots[key] must be a Component, string or an array " +
-              "of Components"
-          );
-        }
-        requiresTemplateCompiler(slotValue);
-      });
-    }
+    slot.forEach(function (slotValue) {
+      if (!isValidSlot(slotValue)) {
+        throwError(
+          "slots[key] must be a Component, string or an array " +
+            "of Components"
+        );
+      }
+      requiresTemplateCompiler(slotValue);
+    });
   });
 }
 
@@ -387,7 +469,7 @@ function createFunctionalComponent (
           mountingOptions.context.children.map(
             function (x) { return (typeof x === 'function' ? x(h) : x); }
           )) ||
-          createSlotVNodes(h, mountingOptions.slots || {})
+          createSlotVNodes(this, mountingOptions.slots || {})
       )
     },
     name: component.name,
@@ -397,6 +479,105 @@ function createFunctionalComponent (
 
 // 
 
+function isDestructuringSlotScope (slotScope) {
+  return slotScope[0] === '{' && slotScope[slotScope.length - 1] === '}'
+}
+
+function getVueTemplateCompilerHelpers () {
+  var vue = new Vue();
+  var helpers = {};
+  var names = [
+    '_c',
+    '_o',
+    '_n',
+    '_s',
+    '_l',
+    '_t',
+    '_q',
+    '_i',
+    '_m',
+    '_f',
+    '_k',
+    '_b',
+    '_v',
+    '_e',
+    '_u',
+    '_g'
+  ];
+  names.forEach(function (name) {
+    helpers[name] = vue._renderProxy[name];
+  });
+  return helpers
+}
+
+function validateEnvironment () {
+  if (window.navigator.userAgent.match(/PhantomJS/i)) {
+    throwError(
+      "the scopedSlots option does not support PhantomJS. " +
+        "Please use Puppeteer, or pass a component."
+    );
+  }
+  if (vueVersion < 2.5) {
+    throwError("the scopedSlots option is only supported in " + "vue@2.5+.");
+  }
+}
+
+function validateTempldate (template) {
+  if (template.trim().substr(0, 9) === '<template') {
+    throwError(
+      "the scopedSlots option does not support a template " +
+        "tag as the root element."
+    );
+  }
+}
+
+function createScopedSlots (
+  scopedSlotsOption
+) {
+  var scopedSlots = {};
+  if (!scopedSlotsOption) {
+    return scopedSlots
+  }
+  validateEnvironment();
+  var helpers = getVueTemplateCompilerHelpers();
+  var loop = function ( name ) {
+    var template = scopedSlotsOption[name];
+    validateTempldate(template);
+    var render = vueTemplateCompiler.compileToFunctions(template).render;
+    var domParser = new window.DOMParser();
+    var _document = domParser.parseFromString(template, 'text/html');
+    var slotScope = _document.body.firstChild.getAttribute(
+      'slot-scope'
+    );
+    var isDestructuring = isDestructuringSlotScope(slotScope);
+    scopedSlots[name] = function (props) {
+      var obj;
+
+      if (isDestructuring) {
+        return render.call(Object.assign({}, helpers, props))
+      } else {
+        return render.call(Object.assign({}, helpers, ( obj = {}, obj[slotScope] = props, obj)))
+      }
+    };
+  };
+
+  for (var name in scopedSlotsOption) loop( name );
+  return scopedSlots
+}
+
+// 
+
+function compileTemplateForSlots (slots) {
+  Object.keys(slots).forEach(function (key) {
+    var slot = Array.isArray(slots[key]) ? slots[key] : [slots[key]];
+    slot.forEach(function (slotValue) {
+      if (componentNeedsCompiling(slotValue)) {
+        compileTemplate(slotValue);
+      }
+    });
+  });
+}
+
 function createInstance (
   component,
   options,
@@ -406,6 +587,18 @@ function createInstance (
   // Remove cached constructor
   delete component._Ctor;
 
+  // mounting options are vue-test-utils specific
+  //
+  // instance options are options that are passed to the
+  // root instance when it's instantiated
+  //
+  // component options are the root components options
+  var componentOptions = typeof component === 'function'
+    ? component.extendOptions
+    : component;
+
+  var instanceOptions = extractInstanceOptions(options);
+
   if (options.mocks) {
     addMocks(options.mocks, _Vue);
   }
@@ -426,10 +619,6 @@ function createInstance (
 
   addEventLogger(_Vue);
 
-  var instanceOptions = Object.assign({}, options);
-
-  deleteMountingOptions(instanceOptions);
-
   var stubComponents = createComponentStubs(
     // $FlowIgnore
     component.components,
@@ -449,9 +638,9 @@ function createInstance (
       );
     }
   });
-  Object.keys(component.components || {}).forEach(function (c) {
+  Object.keys(componentOptions.components || {}).forEach(function (c) {
     if (
-      component.components[c].extendOptions &&
+      componentOptions.components[c].extendOptions &&
       !instanceOptions.components[c]
     ) {
       if (options.logModifiedComponents) {
@@ -464,7 +653,9 @@ function createInstance (
           "option."
         );
       }
-      instanceOptions.components[c] = _Vue.extend(component.components[c]);
+      instanceOptions.components[c] = _Vue.extend(
+        componentOptions.components[c]
+      );
     }
   });
 
@@ -482,6 +673,8 @@ function createInstance (
   });
 
   if (options.slots) {
+    compileTemplateForSlots(options.slots);
+    // $FlowIgnore
     validateSlots(options.slots);
   }
 
@@ -496,52 +689,66 @@ function createInstance (
     options.provide = function () { return obj; };
   }
 
-  var Parent = _Vue.extend({
-    provide: options.provide,
-    render: function render (h) {
-      var slots = options.slots
-        ? createSlotVNodes(h, options.slots)
-        : undefined;
-      return h(
-        Constructor,
-        {
-          ref: 'vm',
-          props: options.propsData,
-          on: options.listeners,
-          attrs: options.attrs
-        },
-        slots
-      )
-    }
-  });
+  var scopedSlots = createScopedSlots(options.scopedSlots);
+
+  if (options.parentComponent && !isPlainObject(options.parentComponent)) {
+    throwError(
+      "options.parentComponent should be a valid Vue component " +
+      "options object"
+    );
+  }
+
+  var parentComponentOptions = options.parentComponent || {};
+  parentComponentOptions.provide = options.provide;
+  parentComponentOptions.render = function (h) {
+    var slots = options.slots
+      ? createSlotVNodes(this, options.slots)
+      : undefined;
+    return h(
+      Constructor,
+      {
+        ref: 'vm',
+        props: options.propsData,
+        on: options.listeners,
+        attrs: options.attrs,
+        scopedSlots: scopedSlots
+      },
+      slots
+    )
+  };
+  var Parent = _Vue.extend(parentComponentOptions);
 
   return new Parent()
 }
 
 // 
 
-function getOptions (key, options, config) {
-  if (options || (config[key] && Object.keys(config[key]).length > 0)) {
-    if (options instanceof Function) {
-      return options
-    } else if (Array.isArray(options)) {
-      return options.concat( Object.keys(config[key] || {}))
-    } else if (!(config[key] instanceof Function)) {
-      return Object.assign({}, config[key],
-        options)
-    } else {
+function getOption (option, config) {
+  if (option || (config && Object.keys(config).length > 0)) {
+    if (option instanceof Function) {
+      return option
+    } else if (Array.isArray(option)) {
+      return option.concat( Object.keys(config || {}))
+    } else if (config instanceof Function) {
       throw new Error("Config can't be a Function.")
+    } else {
+      return Object.assign({}, config,
+        option)
     }
   }
 }
 
 function mergeOptions (options, config) {
+  var mocks = (getOption(options.mocks, config.mocks));
+  var methods = (
+    (getOption(options.methods, config.methods)));
+  var provide = ((getOption(options.provide, config.provide)));
   return Object.assign({}, options,
     {logModifiedComponents: config.logModifiedComponents,
-    stubs: getOptions('stubs', options.stubs, config),
-    mocks: getOptions('mocks', options.mocks, config),
-    methods: getOptions('methods', options.methods, config),
-    provide: getOptions('provide', options.provide, config),
+    stubs: getOption(options.stubs, config.stubs),
+    mocks: mocks,
+    methods: methods,
+    provide: provide,
     sync: !!(options.sync || options.sync === undefined)})
 }