@prismicio/vue 2.0.11 → 2.1.0-alpha.0

package/components/umd.js

@@ -1,34 +1,25 @@
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('prismic-dom')) :
   typeof define === 'function' && define.amd ? define(['exports', 'prismic-dom'], factory) :
-  (factory((global.PrismicVueComponents = {}),global.prismicDOM));
-}(this, (function (exports,PrismicDom) { 'use strict';
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.PrismicVueComponents = {}, global.prismicDOM));
+})(this, (function (exports, PrismicDom) { 'use strict';
 
-  var PrismicDom__default = 'default' in PrismicDom ? PrismicDom['default'] : PrismicDom;
+  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-  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;
-  }
+  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 @@
     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;
+  }
+
   var Embed = {
     name: 'PrismicEmbed',
     functional: true,
@@ -127,11 +133,24 @@
     }
   };
 
+  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: {
@@ -141,6 +160,21 @@
         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) {
@@ -155,11 +189,11 @@
           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);
@@ -167,23 +201,33 @@
 
         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
@@ -191,15 +235,15 @@
       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;
 
@@ -207,7 +251,7 @@
         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
@@ -216,17 +260,203 @@
     }
   };
 
+  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 defineSliceZoneComponents = function defineSliceZoneComponents(components) {
+    return components;
+  };
+  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
@@ -235,16 +465,21 @@
       Link: VueRouterLink
     }
   };
+  exp.common;
+  exp.nuxt;
+  exp.vueRouter;
 
-  var common$1 = exp.common;
-  var nuxt$1 = exp.nuxt;
-  var vueRouter$1 = exp.vueRouter;
+  var common = exp.common;
+  var nuxt = exp.nuxt;
+  var vueRouter = exp.vueRouter;
 
-  exports.common = common$1;
-  exports.nuxt = nuxt$1;
-  exports.vueRouter = vueRouter$1;
-  exports.default = exp;
+  exports.common = common;
+  exports["default"] = exp;
+  exports.defineSliceZoneComponents = defineSliceZoneComponents;
+  exports.getSliceComponentProps = getSliceComponentProps;
+  exports.nuxt = nuxt;
+  exports.vueRouter = vueRouter;
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));