Your IP : 3.15.231.121
/* eslint-disable */
;(function() {
if (
typeof this.BX !== 'undefined'
&& typeof this.BX.Vue !== 'undefined'
&& typeof this.BX.Vue.PortalVue !== 'undefined'
)
{
var currentVersion = '2.1.7';
if (this.BX.Vue.PortalVue.version !== currentVersion)
{
console.warn('BX.Vuex already loaded. Loaded: ' + this.BX.Vue.PortalVue.version + ', Skipped: ' + currentVersion + '. Version differences may cause errors!');
}
return;
}
this.BX = this.BX || {};
(function (exports,ui_vue) {
'use strict';
/*!
* portal-vue (C) Thorsten Lunborg, 2019
* Version: 2.1.7
* LICENCE: MIT
* https://github.com/linusborg/portal-vue
*
* @source: https://unpkg.com/portal-vue@2.1.7/dist/portal-vue.esm.js
*/
// origin-start
function _typeof(obj) {
if (typeof Symbol === "function" && babelHelpers["typeof"](Symbol.iterator) === "symbol") {
_typeof = function _typeof(obj) {
return babelHelpers["typeof"](obj);
};
} else {
_typeof = function _typeof(obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : babelHelpers["typeof"](obj);
};
}
return _typeof(obj);
}
function _toConsumableArray(arr) {
return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
}
function _arrayWithoutHoles(arr) {
if (Array.isArray(arr)) {
for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
return arr2;
}
}
function _iterableToArray(iter) {
if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
}
function _nonIterableSpread() {
throw new TypeError("Invalid attempt to spread non-iterable instance");
}
var inBrowser = typeof window !== 'undefined';
function freeze(item) {
if (Array.isArray(item) || _typeof(item) === 'object') {
return Object.freeze(item);
}
return item;
}
function combinePassengers(transports) {
var slotProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
return transports.reduce(function (passengers, transport) {
var temp = transport.passengers[0];
var newPassengers = typeof temp === 'function' ? temp(slotProps) : transport.passengers;
return passengers.concat(newPassengers);
}, []);
}
function stableSort(array, compareFn) {
return array.map(function (v, idx) {
return [idx, v];
}).sort(function (a, b) {
return compareFn(a[1], b[1]) || a[0] - b[0];
}).map(function (c) {
return c[1];
});
}
function pick(obj, keys) {
return keys.reduce(function (acc, key) {
if (obj.hasOwnProperty(key)) {
acc[key] = obj[key];
}
return acc;
}, {});
}
var transports = {};
var targets = {};
var sources = {};
var Wormhole = ui_vue.VueVendor.extend({
data: function data() {
return {
transports: transports,
targets: targets,
sources: sources,
trackInstances: inBrowser
};
},
methods: {
open: function open(transport) {
if (!inBrowser) return;
var to = transport.to,
from = transport.from,
passengers = transport.passengers,
_transport$order = transport.order,
order = _transport$order === void 0 ? Infinity : _transport$order;
if (!to || !from || !passengers) return;
var newTransport = {
to: to,
from: from,
passengers: freeze(passengers),
order: order
};
var keys = Object.keys(this.transports);
if (keys.indexOf(to) === -1) {
ui_vue.VueVendor.set(this.transports, to, []);
}
var currentIndex = this.$_getTransportIndex(newTransport); // Copying the array here so that the PortalTarget change event will actually contain two distinct arrays
var newTransports = this.transports[to].slice(0);
if (currentIndex === -1) {
newTransports.push(newTransport);
} else {
newTransports[currentIndex] = newTransport;
}
this.transports[to] = stableSort(newTransports, function (a, b) {
return a.order - b.order;
});
},
close: function close(transport) {
var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var to = transport.to,
from = transport.from;
if (!to || !from && force === false) return;
if (!this.transports[to]) {
return;
}
if (force) {
this.transports[to] = [];
} else {
var index = this.$_getTransportIndex(transport);
if (index >= 0) {
// Copying the array here so that the PortalTarget change event will actually contain two distinct arrays
var newTransports = this.transports[to].slice(0);
newTransports.splice(index, 1);
this.transports[to] = newTransports;
}
}
},
registerTarget: function registerTarget(target, vm, force) {
if (!inBrowser) return;
if (this.trackInstances && !force && this.targets[target]) {
console.warn("[portal-vue]: Target ".concat(target, " already exists"));
}
this.$set(this.targets, target, Object.freeze([vm]));
},
unregisterTarget: function unregisterTarget(target) {
this.$delete(this.targets, target);
},
registerSource: function registerSource(source, vm, force) {
if (!inBrowser) return;
if (this.trackInstances && !force && this.sources[source]) {
console.warn("[portal-vue]: source ".concat(source, " already exists"));
}
this.$set(this.sources, source, Object.freeze([vm]));
},
unregisterSource: function unregisterSource(source) {
this.$delete(this.sources, source);
},
hasTarget: function hasTarget(to) {
return !!(this.targets[to] && this.targets[to][0]);
},
hasSource: function hasSource(to) {
return !!(this.sources[to] && this.sources[to][0]);
},
hasContentFor: function hasContentFor(to) {
return !!this.transports[to] && !!this.transports[to].length;
},
// Internal
$_getTransportIndex: function $_getTransportIndex(_ref) {
var to = _ref.to,
from = _ref.from;
for (var i in this.transports[to]) {
if (this.transports[to][i].from === from) {
return +i;
}
}
return -1;
}
}
});
var wormhole = new Wormhole(transports);
var _id = 1;
var Portal = ui_vue.VueVendor.extend({
name: 'portal',
props: {
disabled: {
type: Boolean
},
name: {
type: String,
"default": function _default() {
return String(_id++);
}
},
order: {
type: Number,
"default": 0
},
slim: {
type: Boolean
},
slotProps: {
type: Object,
"default": function _default() {
return {};
}
},
tag: {
type: String,
"default": 'DIV'
},
to: {
type: String,
"default": function _default() {
return String(Math.round(Math.random() * 10000000));
}
}
},
created: function created() {
var _this = this;
this.$nextTick(function () {
wormhole.registerSource(_this.name, _this);
});
},
mounted: function mounted() {
if (!this.disabled) {
this.sendUpdate();
}
},
updated: function updated() {
if (this.disabled) {
this.clear();
} else {
this.sendUpdate();
}
},
beforeDestroy: function beforeDestroy() {
wormhole.unregisterSource(this.name);
this.clear();
},
watch: {
to: function to(newValue, oldValue) {
oldValue && oldValue !== newValue && this.clear(oldValue);
this.sendUpdate();
}
},
methods: {
clear: function clear(target) {
var closer = {
from: this.name,
to: target || this.to
};
wormhole.close(closer);
},
normalizeSlots: function normalizeSlots() {
return this.$scopedSlots["default"] ? [this.$scopedSlots["default"]] : this.$slots["default"];
},
normalizeOwnChildren: function normalizeOwnChildren(children) {
return typeof children === 'function' ? children(this.slotProps) : children;
},
sendUpdate: function sendUpdate() {
var slotContent = this.normalizeSlots();
if (slotContent) {
var transport = {
from: this.name,
to: this.to,
passengers: _toConsumableArray(slotContent),
order: this.order
};
wormhole.open(transport);
} else {
this.clear();
}
}
},
render: function render(h) {
var children = this.$slots["default"] || this.$scopedSlots["default"] || [];
var Tag = this.tag;
if (children && this.disabled) {
return children.length <= 1 && this.slim ? this.normalizeOwnChildren(children)[0] : h(Tag, [this.normalizeOwnChildren(children)]);
} else {
return this.slim ? h() : h(Tag, {
"class": {
'v-portal': true
},
style: {
display: 'none'
},
key: 'v-portal-placeholder'
});
}
}
});
var PortalTarget = ui_vue.VueVendor.extend({
name: 'portalTarget',
props: {
multiple: {
type: Boolean,
"default": false
},
name: {
type: String,
required: true
},
slim: {
type: Boolean,
"default": false
},
slotProps: {
type: Object,
"default": function _default() {
return {};
}
},
tag: {
type: String,
"default": 'div'
},
transition: {
type: [String, Object, Function]
}
},
data: function data() {
return {
transports: wormhole.transports,
firstRender: true
};
},
created: function created() {
var _this = this;
this.$nextTick(function () {
wormhole.registerTarget(_this.name, _this);
});
},
watch: {
ownTransports: function ownTransports() {
this.$emit('change', this.children().length > 0);
},
name: function name(newVal, oldVal) {
/**
* TODO
* This should warn as well ...
*/
wormhole.unregisterTarget(oldVal);
wormhole.registerTarget(newVal, this);
}
},
mounted: function mounted() {
var _this2 = this;
if (this.transition) {
this.$nextTick(function () {
// only when we have a transition, because it causes a re-render
_this2.firstRender = false;
});
}
},
beforeDestroy: function beforeDestroy() {
wormhole.unregisterTarget(this.name);
},
computed: {
ownTransports: function ownTransports() {
var transports = this.transports[this.name] || [];
if (this.multiple) {
return transports;
}
return transports.length === 0 ? [] : [transports[transports.length - 1]];
},
passengers: function passengers() {
return combinePassengers(this.ownTransports, this.slotProps);
}
},
methods: {
// can't be a computed prop because it has to "react" to $slot changes.
children: function children() {
return this.passengers.length !== 0 ? this.passengers : this.$scopedSlots["default"] ? this.$scopedSlots["default"](this.slotProps) : this.$slots["default"] || [];
},
// can't be a computed prop because it has to "react" to this.children().
noWrapper: function noWrapper() {
var noWrapper = this.slim && !this.transition;
if (noWrapper && this.children().length > 1) {
console.warn('[portal-vue]: PortalTarget with `slim` option received more than one child element.');
}
return noWrapper;
}
},
render: function render(h) {
var noWrapper = this.noWrapper();
var children = this.children();
var Tag = this.transition || this.tag;
return noWrapper ? children[0] : this.slim && !Tag ? h() : h(Tag, {
props: {
// if we have a transition component, pass the tag if it exists
tag: this.transition && this.tag ? this.tag : undefined
},
"class": {
'vue-portal-target': true
}
}, children);
}
});
var _id$1 = 0;
var portalProps = ['disabled', 'name', 'order', 'slim', 'slotProps', 'tag', 'to'];
var targetProps = ['multiple', 'transition'];
var MountingPortal = ui_vue.VueVendor.extend({
name: 'MountingPortal',
inheritAttrs: false,
props: {
append: {
type: [Boolean, String]
},
bail: {
type: Boolean
},
mountTo: {
type: String,
required: true
},
// Portal
disabled: {
type: Boolean
},
// name for the portal
name: {
type: String,
"default": function _default() {
return 'mounted_' + String(_id$1++);
}
},
order: {
type: Number,
"default": 0
},
slim: {
type: Boolean
},
slotProps: {
type: Object,
"default": function _default() {
return {};
}
},
tag: {
type: String,
"default": 'DIV'
},
// name for the target
to: {
type: String,
"default": function _default() {
return String(Math.round(Math.random() * 10000000));
}
},
// Target
multiple: {
type: Boolean,
"default": false
},
targetSlim: {
type: Boolean
},
targetSlotProps: {
type: Object,
"default": function _default() {
return {};
}
},
targetTag: {
type: String,
"default": 'div'
},
transition: {
type: [String, Object, Function]
}
},
created: function created() {
if (typeof document === 'undefined') return;
var el = document.querySelector(this.mountTo);
if (!el) {
console.error("[portal-vue]: Mount Point '".concat(this.mountTo, "' not found in document"));
return;
}
var props = this.$props; // Target already exists
if (wormhole.targets[props.name]) {
if (props.bail) {
console.warn("[portal-vue]: Target ".concat(props.name, " is already mounted.\n Aborting because 'bail: true' is set"));
} else {
this.portalTarget = wormhole.targets[props.name];
}
return;
}
var append = props.append;
if (append) {
var type = typeof append === 'string' ? append : 'DIV';
var mountEl = document.createElement(type);
el.appendChild(mountEl);
el = mountEl;
} // get props for target from $props
// we have to rename a few of them
var _props = pick(this.$props, targetProps);
_props.slim = this.targetSlim;
_props.tag = this.targetTag;
_props.slotProps = this.targetSlotProps;
_props.name = this.to;
this.portalTarget = new PortalTarget({
el: el,
parent: this.$parent || this,
propsData: _props
});
},
beforeDestroy: function beforeDestroy() {
var target = this.portalTarget;
if (this.append) {
var el = target.$el;
el.parentNode.removeChild(el);
}
target.$destroy();
},
render: function render(h) {
if (!this.portalTarget) {
console.warn("[portal-vue] Target wasn't mounted");
return h();
} // if there's no "manual" scoped slot, so we create a <Portal> ourselves
if (!this.$scopedSlots.manual) {
var props = pick(this.$props, portalProps);
return h(Portal, {
props: props,
attrs: this.$attrs,
on: this.$listeners,
scopedSlots: this.$scopedSlots
}, this.$slots["default"]);
} // else, we render the scoped slot
var content = this.$scopedSlots.manual({
to: this.to
}); // if user used <template> for the scoped slot
// content will be an array
if (Array.isArray(content)) {
content = content[0];
}
if (!content) return h();
return content;
}
});
function install(Vue$$1) {
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
Vue$$1.component(options.portalName || 'Portal', Portal);
Vue$$1.component(options.portalTargetName || 'PortalTarget', PortalTarget);
Vue$$1.component(options.MountingPortalName || 'MountingPortal', MountingPortal);
}
var index = {
install: install
};
// origin-end
index.version = '2.1.7';
exports.PortalVue = index;
exports.Portal = Portal;
exports.PortalTarget = PortalTarget;
exports.MountingPortal = MountingPortal;
exports.Wormhole = wormhole;
}((this.BX.Vue = this.BX.Vue || {}),BX));
})();
//# sourceMappingURL=portal.bundle.js.map