@prismicio/vue 2.0.11 → 2.1.0-alpha.0

package/dist/prismic-vue.common.js

@@ -1,34 +1,25 @@
 'use strict';
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
+var prismicJS = require('@prismicio/client');
 var PrismicDOM = require('prismic-dom');
-var PrismicDOM__default = _interopDefault(PrismicDOM);
-var prismicJS = _interopDefault(require('@prismicio/client'));
 
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-  return obj;
-}
+var prismicJS__default = /*#__PURE__*/_interopDefaultLegacy(prismicJS);
+var PrismicDOM__default = /*#__PURE__*/_interopDefaultLegacy(PrismicDOM);
 
 function ownKeys(object, enumerableOnly) {
   var keys = Object.keys(object);
 
   if (Object.getOwnPropertySymbols) {
     var symbols = Object.getOwnPropertySymbols(object);
-    if (enumerableOnly) symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    });
+
+    if (enumerableOnly) {
+      symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+    }
+
     keys.push.apply(keys, symbols);
   }
 
@@ -55,6 +46,21 @@ function _objectSpread2(target) {
   return target;
 }
 
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
 function _slicedToArray(arr, i) {
   return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
 }
@@ -64,14 +70,17 @@ function _arrayWithHoles(arr) {
 }
 
 function _iterableToArrayLimit(arr, i) {
-  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+  if (_i == null) return;
   var _arr = [];
   var _n = true;
   var _d = false;
-  var _e = undefined;
+
+  var _s, _e;
 
   try {
-    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
       _arr.push(_s.value);
 
       if (i && _arr.length === i) break;
@@ -183,11 +192,24 @@ var Image = {
   }
 };
 
+var isInternalURL = function isInternalURL(url) {
+  /**
+   * @see Regex101 expression: {@link https://regex101.com/r/1y7iod/1}
+   */
+  var isInternal = /^\/(?!\/)/.test(url);
+  /**
+   * @see Regex101 expression: {@link https://regex101.com/r/RnUseS/1}
+   */
+
+  var isSpecialLink = !isInternal && !/^https?:\/\//i.test(url);
+  return isInternal && !isSpecialLink;
+};
+
 var Link = (function (_ref) {
   var _ref$component = _ref.component,
-      component = _ref$component === void 0 ? 'a' : _ref$component;
+      component = _ref$component === void 0 ? "a" : _ref$component;
   return {
-    name: 'PrismicLink',
+    name: "PrismicLink",
     functional: true,
     props: {
       field: {
@@ -197,6 +219,21 @@ var Link = (function (_ref) {
       linkResolver: {
         type: Function,
         required: false
+      },
+      target: {
+        type: String,
+        "default": undefined,
+        required: false
+      },
+      rel: {
+        type: String,
+        "default": undefined,
+        required: false
+      },
+      blankTargetRelAttribute: {
+        type: String,
+        "default": "noopener",
+        required: false
       }
     },
     render: function render(h, _ref2) {
@@ -211,11 +248,11 @@ var Link = (function (_ref) {
         return null;
       }
 
-      var url = parent.$prismic ? parent.$prismic.asLink(field, linkResolver) : PrismicDOM__default.Link.url(field, linkResolver || function () {
+      var url = parent.$prismic ? parent.$prismic.asLink(field, linkResolver) : PrismicDOM__default["default"].Link.url(field, linkResolver || function () {
         return null;
       });
 
-      if (url.indexOf('/') === 0) {
+      if (isInternalURL(url) && !props.target) {
         data.props = data.props || {};
         data.props.to = url;
         return h(component, data, children);
@@ -223,23 +260,33 @@ var Link = (function (_ref) {
 
       data.attrs = _objectSpread2(_objectSpread2({}, data.attrs), {}, {
         href: url
-      }, field.target && {
-        target: field.target,
-        rel: 'noopener'
       });
-      return h('a', data, children);
+
+      if (typeof props.target !== "undefined" || field.target) {
+        data.attrs.target = typeof props.target !== "undefined" ? props.target : field.target;
+
+        if (data.attrs.target === "_blank") {
+          data.attrs.rel = typeof props.rel !== "undefined" ? props.rel : props.blankTargetRelAttribute;
+        }
+      }
+
+      return h("a", data, children);
     }
   };
 });
 
 var RichText = {
-  name: 'PrismicRichText',
+  name: "PrismicRichText",
   functional: true,
   props: {
     field: {
       type: Array,
       required: true
     },
+    linkResolver: {
+      type: Function,
+      required: false
+    },
     htmlSerializer: {
       type: Function,
       required: false
@@ -247,15 +294,15 @@ var RichText = {
     wrapper: {
       type: String,
       required: false,
-      "default": 'div'
+      "default": "div"
     }
   },
   render: function render(h, _ref) {
     var props = _ref.props,
         data = _ref.data,
-        children = _ref.children,
         parent = _ref.parent;
     var field = props.field,
+        linkResolver = props.linkResolver,
         htmlSerializer = props.htmlSerializer,
         wrapper = props.wrapper;
 
@@ -263,7 +310,7 @@ var RichText = {
       return null;
     }
 
-    var innerHTML = PrismicDOM.RichText.asHtml(field, parent.$prismic.linkResolver, htmlSerializer || parent.$prismic.htmlSerializer);
+    var innerHTML = PrismicDOM.RichText.asHtml(field, linkResolver || parent.$prismic.linkResolver, htmlSerializer || parent.$prismic.htmlSerializer);
     return h(wrapper, _objectSpread2(_objectSpread2({}, data), {}, {
       domProps: {
         innerHTML: innerHTML
@@ -272,17 +319,199 @@ var RichText = {
   }
 };
 
+var Text = {
+  name: "PrismicText",
+  functional: true,
+  props: {
+    field: {
+      type: Array,
+      required: true
+    },
+    separator: {
+      type: String,
+      "default": undefined,
+      required: false
+    },
+    wrapper: {
+      type: String,
+      required: false,
+      "default": "div"
+    }
+  },
+  render: function render(h, _ref) {
+    var props = _ref.props,
+        data = _ref.data;
+        _ref.children;
+        _ref.parent;
+    var field = props.field,
+        separator = props.separator,
+        wrapper = props.wrapper;
+
+    if (!field) {
+      return null;
+    }
+
+    var innerHTML = PrismicDOM.RichText.asText(field, separator);
+    return h(wrapper, _objectSpread2(_objectSpread2({}, data), {}, {
+      domProps: {
+        innerHTML: innerHTML
+      }
+    }));
+  }
+};
+
+// We need to polyfill process if it doesn't exist, such as in the browser.
+if (typeof process === "undefined") {
+  globalThis.process = {
+    env: {}
+  };
+}
+/**
+ * `true` if in the production environment, `false` otherwise.
+ *
+ * This boolean can be used to perform actions only in development environments,
+ * such as logging.
+ */
+
+
+var __PRODUCTION__ = process.env.NODE_ENV === "production";
+
+var getSliceComponentProps = function getSliceComponentProps(propsHint) {
+  return {
+    slice: {
+      type: Object,
+      required: true
+    },
+    index: {
+      type: Number,
+      required: true
+    },
+    slices: {
+      type: Array,
+      required: true
+    },
+    context: {
+      type: null,
+      required: true
+    }
+  };
+};
+var TODOSliceComponent = __PRODUCTION__ ? function () {
+  return null;
+} : {
+  name: "TODOSliceCOmponent",
+  functional: true,
+  props: getSliceComponentProps(),
+  renfer: function renfer(h, _ref) {
+    var props = _ref.props,
+        data = _ref.data;
+    console.warn("[SliceZone] Could not find a component for Slice type \"".concat(props.slice.slice_type, "\""), props.slice);
+    return function () {
+      return h("section", _objectSpread2(_objectSpread2({}, data), {}, {
+        "data-slice-zone-todo-component": "",
+        "data-slice-type": props.slice.slice_type
+      }), ["Could not find a component for Slice type \"".concat(props.slice.slice_type, "\"")]);
+    };
+  }
+}; // Just mimiced to prevent confusion but doesn't provide any value with version 2 of this kit
+var SliceZone = {
+  name: "SliceZone",
+  functional: true,
+  props: {
+    slices: {
+      type: Array,
+      required: true
+    },
+    components: {
+      type: Object,
+      "default": undefined,
+      required: false
+    },
+    resolver: {
+      type: Function,
+      "default": undefined,
+      required: false
+    },
+    context: {
+      type: null,
+      "default": undefined,
+      required: false
+    },
+    defaultComponent: {
+      type: Object,
+      "default": undefined,
+      required: false
+    },
+    wrapper: {
+      type: [String, Object, Function],
+      "default": "div",
+      required: false
+    }
+  },
+  render: function render(h, _ref2) {
+    var props = _ref2.props,
+        data = _ref2.data;
+
+    // Prevent fatal if user didn't check for field, throws `Invalid prop` warn
+    if (!props.slices) {
+      return function () {
+        return null;
+      };
+    }
+
+    var renderedSlices = computed(function () {
+      return props.slices.map(function (slice, index) {
+        var component = props.components && slice.slice_type in props.components ? props.components[slice.slice_type] : props.defaultComponent || TODOSliceComponent; // TODO: Remove `resolver` in v3 in favor of `components`.
+
+        if (props.resolver) {
+          var resolvedComponent = props.resolver({
+            slice: slice,
+            sliceName: slice.slice_type,
+            i: index
+          });
+
+          if (resolvedComponent) {
+            component = resolvedComponent;
+          }
+        }
+
+        var p = {
+          key: "".concat(slice.slice_type, "-").concat(index),
+          slice: slice,
+          index: index,
+          context: props.context,
+          slices: props.slices
+        };
+        return h(component, p);
+      });
+    });
+    var parent = props.wrapper;
+
+    if (typeof parent === "string") {
+      return h(parent, data, renderedSlices.value);
+    } else {
+      return h(parent, data, {
+        "default": function _default() {
+          return renderedSlices.value;
+        }
+      });
+    }
+  }
+};
+
 var NuxtLink = Link({
-  component: 'nuxt-link'
+  component: "nuxt-link"
 });
 var VueRouterLink = Link({
-  component: 'router-link'
+  component: "router-link"
 });
 var exp = {
   common: {
     Embed: Embed,
     Image: Image,
-    RichText: RichText
+    RichText: RichText,
+    Text: Text,
+    SliceZone: SliceZone
   },
   nuxt: {
     Link: NuxtLink
@@ -294,24 +523,24 @@ var exp = {
 
 function asHtml(richText, linkResolver, htmlSerializer) {
   if (richText) {
-    return PrismicDOM__default.RichText.asHtml(richText, linkResolver, htmlSerializer);
+    return PrismicDOM__default["default"].RichText.asHtml(richText, linkResolver, htmlSerializer);
   }
 }
 function asText(richText, joinString) {
   if (richText) {
-    return PrismicDOM__default.RichText.asText(richText, joinString);
+    return PrismicDOM__default["default"].RichText.asText(richText, joinString);
   }
 
   return '';
 }
 function asLink(link, linkResolver) {
   if (link) {
-    return PrismicDOM__default.Link.url(link, linkResolver);
+    return PrismicDOM__default["default"].Link.url(link, linkResolver);
   }
 }
 function asDate(date) {
   if (date) {
-    return PrismicDOM__default.Date(date);
+    return PrismicDOM__default["default"].Date(date);
   }
 }
 
@@ -320,6 +549,7 @@ function attachMethods(Vue, options) {
     return asHtml(richText, linkResolver || options.linkResolver, htmlSerializer || options.htmlSerializer);
   };
 
+  Vue.prototype.$prismic.asHTML = Vue.prototype.$prismic.asHtml;
   Vue.prototype.$prismic.asText = asText;
   Vue.prototype.$prismic.richTextAsPlain = asText;
   Vue.prototype.$prismic.asDate = asDate;
@@ -332,12 +562,12 @@ function attachMethods(Vue, options) {
 var PrismicVue = {
   install: function install(Vue, options) {
     var _options$linkType = options.linkType,
-        linkType = _options$linkType === void 0 ? 'vueRouter' : _options$linkType;
-    Vue.prototype.$prismic = prismicJS;
+        linkType = _options$linkType === void 0 ? "vueRouter" : _options$linkType;
+    Vue.prototype.$prismic = prismicJS__default["default"];
     Vue.prototype.$prismic.endpoint = options.endpoint;
     Vue.prototype.$prismic.linkResolver = options.linkResolver;
     Vue.prototype.$prismic.htmlSerializer = options.htmlSerializer;
-    Vue.prototype.$prismic.client = prismicJS.client(options.endpoint, options.apiOptions);
+    Vue.prototype.$prismic.client = prismicJS__default["default"].client(options.endpoint, options.apiOptions);
     attachMethods(Vue, options);
 
     var components = _objectSpread2(_objectSpread2({}, exp.common), exp[linkType]);
@@ -348,9 +578,9 @@ var PrismicVue = {
 
 
     Object.entries(components).forEach(function (_ref) {
-      var _ref2 = _slicedToArray(_ref, 2),
-          _ = _ref2[0],
-          c = _ref2[1];
+      var _ref2 = _slicedToArray(_ref, 2);
+          _ref2[0];
+          var c = _ref2[1];
 
       Vue.component(c.name, c);
     });