← All changes | admin/resources/vbocore.js +4668 -0 1.6.2 → 1.8.16 View file →

		@@ -1,0 +1,4668 @@
	1	+/**
	2	+ * VikBooking Core v1.8.8
	3	+ * Copyright (C) 2026 E4J s.r.l. All Rights Reserved.
	4	+ * http://www.gnu.org/licenses/gpl-2.0.html GNU/GPL
	5	+ * https://vikwp.com | https://e4j.com | https://e4jconnect.com
	6	+ */
	7	+(function($, w) {
	8	+ 'use strict';
	9	+
	10	+ /**
	11	+ * AJAX loading of Views may reload the already existing options, so we cache them when available.
	12	+ */
	13	+ var CORE_OPTIONS = typeof VBOCore !== 'undefined' ? VBOCore?.options : null;
	14	+
	15	+ /**
	16	+ * VBOCore class implementation.
	17	+ */
	18	+ w['VBOCore'] = class VBOCore {
	19	+
	20	+ /**
	21	+ * Proxy to support static injection of params.
	22	+ */
	23	+ constructor(params) {
	24	+ VBOCore.setOptions(params);
	25	+ }
	26	+
	27	+ /**
	28	+ * Inject options by overriding default properties.
	29	+ *
	30	+ * @param object params
	31	+ *
	32	+ * @return self
	33	+ */
	34	+ static setOptions(params) {
	35	+ if (params != null && typeof params === 'object') {
	36	+ VBOCore.options = Object.assign(VBOCore.options, params);
	37	+ }
	38	+
	39	+ return VBOCore;
	40	+ }
	41	+
	42	+ /**
	43	+ * Fires a given function when the DOM content has loaded.
	44	+ *
	45	+ * @param function fireFn The function to fire when the document is ready.
	46	+ *
	47	+ * @return undefined
	48	+ */
	49	+ static DOMLoaded(fireFn) {
	50	+ if (typeof fireFn !== 'function') {
	51	+ throw new Error('Invalid argument provided');
	52	+ }
	53	+
	54	+ if (document.readyState === 'loading') {
	55	+ // register event because DOMContentLoaded hasn't finished yet
	56	+ document.addEventListener('DOMContentLoaded', fireFn);
	57	+ } else {
	58	+ // DOMContentLoaded event has fired already
	59	+ fireFn();
	60	+ }
	61	+ }
	62	+
	63	+ /**
	64	+ * Returns a promise that resolves when the specified instance gets defined.
	65	+ *
	66	+ * @param function check The callback to invoke to check whether the instance is ready.
	67	+ * @param mixed threshold An optional threshold to estabilish the max number of attempts.
	68	+ *
	69	+ * @return Promise
	70	+ */
	71	+ static onInstanceReady(check, threshold) {
	72	+ return new Promise((resolve, reject) => {
	73	+ // prepare safe counter
	74	+ let count = 0;
	75	+
	76	+ const callback = function() {
	77	+ // increase counter
	78	+ count++;
	79	+
	80	+ let instance;
	81	+
	82	+ try {
	83	+ // check whether the instance is ready
	84	+ instance = check();
	85	+ } catch (err) {
	86	+ // an error has occurred, manually abort
	87	+ reject();
	88	+ return;
	89	+ }
	90	+
	91	+ if (instance) {
	92	+ // object is now ready
	93	+ resolve(instance);
	94	+ } else {
	95	+ if (!threshold || count < Math.abs(threshold)) {
	96	+ // check again
	97	+ setTimeout(callback, 32 + Math.floor(Math.random() * 128));
	98	+ } else {
	99	+ // instance not ready
	100	+ reject();
	101	+ }
	102	+ }
	103	+ };
	104	+
	105	+ // check
	106	+ callback();
	107	+ });
	108	+ }
	109	+
	110	+ /**
	111	+ * Getter for admin_widgets private options property.
	112	+ *
	113	+ * @return array
	114	+ */
	115	+ static get admin_widgets() {
	116	+ return VBOCore.options.admin_widgets;
	117	+ }
	118	+
	119	+ /**
	120	+ * Getter for multitask open event private property.
	121	+ *
	122	+ * @return string
	123	+ */
	124	+ static get multitask_open_event() {
	125	+ return VBOCore.options.multitask_open_event;
	126	+ }
	127	+
	128	+ /**
	129	+ * Getter for multitask close event private property.
	130	+ *
	131	+ * @return string
	132	+ */
	133	+ static get multitask_close_event() {
	134	+ return VBOCore.options.multitask_close_event;
	135	+ }
	136	+
	137	+ /**
	138	+ * Getter for multitask shortcut event private property.
	139	+ *
	140	+ * @return string
	141	+ */
	142	+ static get multitask_shortcut_event() {
	143	+ return VBOCore.options.multitask_shortcut_ev;
	144	+ }
	145	+
	146	+ /**
	147	+ * Getter for multitask seach focus shortcut event private property.
	148	+ *
	149	+ * @return string
	150	+ */
	151	+ static get multitask_searchfs_event() {
	152	+ return VBOCore.options.multitask_searchfs_ev;
	153	+ }
	154	+
	155	+ /**
	156	+ * Getter for multitask event widget modal rendered.
	157	+ *
	158	+ * @return string
	159	+ */
	160	+ static get widget_modal_rendered() {
	161	+ return VBOCore.options.widget_modal_rendered;
	162	+ }
	163	+
	164	+ /**
	165	+ * Getter for widget modal dismiss event.
	166	+ *
	167	+ * @return string
	168	+ */
	169	+ static get widget_modal_dismissed() {
	170	+ return VBOCore.options.widget_modal_dismissed;
	171	+ }
	172	+
	173	+ /**
	174	+ * Getter for the service worker file path.
	175	+ *
	176	+ * @return string
	177	+ */
	178	+ static get service_worker_path() {
	179	+ return VBOCore.options.service_worker_path;
	180	+ }
	181	+
	182	+ /**
	183	+ * Getter for the service worker scope.
	184	+ *
	185	+ * @return string
	186	+ */
	187	+ static get service_worker_scope() {
	188	+ return VBOCore.options.service_worker_scope;
	189	+ }
	190	+
	191	+ /**
	192	+ * Getter for the push application key.
	193	+ *
	194	+ * @return string
	195	+ */
	196	+ static get push_application_key() {
	197	+ return VBOCore.options.push.application_key;
	198	+ }
	199	+
	200	+ /**
	201	+ * Getter for the push storage endpoint identifier.
	202	+ *
	203	+ * @return string
	204	+ */
	205	+ static get push_storage_endpoint_id() {
	206	+ return VBOCore.options.push_options.storage_endp_id;
	207	+ }
	208	+
	209	+ /**
	210	+ * Parses an AJAX response error object.
	211	+ *
	212	+ * @param object err
	213	+ *
	214	+ * @return bool
	215	+ */
	216	+ static isConnectionLostError(err) {
	217	+ if (!err || !err.hasOwnProperty('status')) {
	218	+ return false;
	219	+ }
	220	+
	221	+ return (
	222	+ err.statusText == 'error'
	223	+ && err.status == 0
	224	+ && (err.readyState == 0 || err.readyState == 4)
	225	+ && (!err.hasOwnProperty('responseText') || err.responseText == '')
	226	+ );
	227	+ }
	228	+
	229	+ /**
	230	+ * Ensures AJAX requests that fail due to connection errors are retried automatically.
	231	+ *
	232	+ * @param string url
	233	+ * @param object data
	234	+ * @param function success
	235	+ * @param function failure
	236	+ * @param number attempt
	237	+ */
	238	+ static doAjax(url, data, success, failure, attempt) {
	239	+ const AJAX_MAX_ATTEMPTS = 3;
	240	+
	241	+ if (attempt === undefined) {
	242	+ attempt = 1;
	243	+ }
	244	+
	245	+ let requestOptions = {
	246	+ type: 'POST',
	247	+ url: url,
	248	+ data: data,
	249	+ };
	250	+
	251	+ if (data instanceof FormData) {
	252	+ // ensure the FormData object is not manipulated
	253	+ requestOptions.processData = false;
	254	+ requestOptions.contentType = false;
	255	+ }
	256	+
	257	+ return $.ajax(
	258	+ requestOptions
	259	+ ).done(function(resp) {
	260	+ if (success !== undefined) {
	261	+ // launch success callback function
	262	+ success(resp);
	263	+ }
	264	+ }).fail(function(err) {
	265	+ /**
	266	+ * If the error is caused by a site connection lost, and if the number
	267	+ * of retries is lower than max attempts, retry the same AJAX request.
	268	+ */
	269	+ if (attempt < AJAX_MAX_ATTEMPTS && VBOCore.isConnectionLostError(err)) {
	270	+ // delay the retry by half second
	271	+ setTimeout(function() {
	272	+ // re-launch same request and increase number of attempts
	273	+ console.log('Retrying previous AJAX request');
	274	+ VBOCore.doAjax(url, data, success, failure, (attempt + 1));
	275	+ }, 500);
	276	+ } else {
	277	+ // launch the failure callback otherwise
	278	+ if (failure !== undefined) {
	279	+ if (err.responseText === 'false') {
	280	+ // make the property empty to rely on others
	281	+ err.responseText = '';
	282	+ }
	283	+ failure(err);
	284	+ }
	285	+ }
	286	+
	287	+ if (!err.status || err.status == 500) {
	288	+ // log the error in console
	289	+ console.error('AJAX request failed' + (err.status == 500 ? ' (' + err.responseText + ')' : ''), err);
	290	+ }
	291	+ });
	292	+ }
	293	+
	294	+ /**
	295	+ * Matches a keyword against a text.
	296	+ *
	297	+ * @param string search the keyword to search.
	298	+ * @param string text the text to compare.
	299	+ *
	300	+ * @return bool
	301	+ */
	302	+ static matchString(search, text) {
	303	+ return ((text + '').indexOf(search) >= 0);
	304	+ }
	305	+
	306	+ /**
	307	+ * Converts a base64 URL for a server key into an array of 8-bit unsigned integers.
	308	+ *
	309	+ * @param string key the base64 encoded URL key.
	310	+ *
	311	+ * @return Uint8Array
	312	+ */
	313	+ static base64ToUint8Array(key) {
	314	+ const padding = ('=').repeat((4 - (key.length % 4)) % 4);
	315	+ const base64 = (key + padding).replace(/\-/g, '+').replace(/_/g, '/');
	316	+
	317	+ const rawData = window.atob(base64);
	318	+ const uint8_arr = new Uint8Array(rawData.length);
	319	+
	320	+ for (let i = 0; i < rawData.length; ++i) {
	321	+ uint8_arr[i] = rawData.charCodeAt(i);
	322	+ }
	323	+
	324	+ return uint8_arr;
	325	+ }
	326	+
	327	+ /**
	328	+ * Builds an object containing the Push subscription details and data.
	329	+ *
	330	+ * @param PushSubscription pushSubscription the registration data.
	331	+ * @param object data the extra data to merge.
	332	+ *
	333	+ * @return object
	334	+ */
	335	+ static buildPushSubscriptionData(pushSubscription, data) {
	336	+ if (!(pushSubscription instanceof PushSubscription)) {
	337	+ return data;
	338	+ }
	339	+
	340	+ let key = pushSubscription.getKey('p256dh');
	341	+ let token = pushSubscription.getKey('auth');
	342	+ let contentEncoding = (PushManager.supportedContentEncodings || ['aesgcm'])[0];
	343	+
	344	+ let details = {
	345	+ endpoint: pushSubscription.endpoint,
	346	+ publicKey: key ? btoa(String.fromCharCode.apply(null, new Uint8Array(key))) : null,
	347	+ authToken: token ? btoa(String.fromCharCode.apply(null, new Uint8Array(token))) : null,
	348	+ encoding: contentEncoding,
	349	+ };
	350	+
	351	+ return Object.assign(details, data);
	352	+ }
	353	+
	354	+ /**
	355	+ * Attempts to install (and eventually update) the VikBooking's Service Worker.
	356	+ *
	357	+ * @param bool update if defined, it will update the Service Worker Registration.
	358	+ *
	359	+ * @return Promise
	360	+ */
	361	+ static installServiceWorker(update) {
	362	+ // check if support for Web App badge is available
	363	+ if (typeof navigator.setAppBadge !== 'undefined') {
	364	+ // always clear the app badge
	365	+ navigator.clearAppBadge();
	366	+ }
	367	+
	368	+ return new Promise((resolve, reject) => {
	369	+ if (!('serviceWorker' in navigator)) {
	370	+ reject('Service workers are not supported by this browser');
	371	+ return;
	372	+ }
	373	+
	374	+ if (!('PushManager' in window)) {
	375	+ reject('Push notifications are not supported by this browser');
	376	+ return;
	377	+ }
	378	+
	379	+ if (!VBOCore.service_worker_path) {
	380	+ reject('Service Worker path not configured');
	381	+ return;
	382	+ }
	383	+
	384	+ if (!VBOCore.notificationsEnabled()) {
	385	+ reject('Notifications are disabled, and so the service worker will not be installed');
	386	+ return;
	387	+ }
	388	+
	389	+ navigator.serviceWorker.register(VBOCore.service_worker_path, {scope: VBOCore.service_worker_scope}).then(
	390	+ (registration) => {
	391	+ if (typeof update !== 'undefined') {
	392	+ // attempt to update the registration for un-caching purposes
	393	+ registration.update().then((updated) => {
	394	+ // all good
	395	+ }).catch((e) => {
	396	+ // updating should never fail after registering with success
	397	+ console.error(`Service worker registration update failed: ${e}`);
	398	+ });
	399	+ }
	400	+
	401	+ // listen to the ServiceWorker messages for the client
	402	+ VBOCore.listenServiceWorkerMessages();
	403	+
	404	+ // resolve the Promise
	405	+ resolve(registration);
	406	+ },
	407	+ (e) => {
	408	+ console.error(`Service worker registration failed: ${e}`);
	409	+ reject('Service worker registration failed');
	410	+ }
	411	+ );
	412	+ });
	413	+ }
	414	+
	415	+ /**
	416	+ * Handles the Push subscription state. To be called after the
	417	+ * Service Worker installation (registration) is ready.
	418	+ *
	419	+ * @param ServiceWorkerRegistration registration sw registration object.
	420	+ *
	421	+ * @return Promise
	422	+ */
	423	+ static handlePushSubscription(registration) {
	424	+ return new Promise((resolve, reject) => {
	425	+ if (!(registration instanceof ServiceWorkerRegistration)) {
	426	+ reject('Missing service worker registration');
	427	+ return;
	428	+ }
	429	+
	430	+ if (!VBOCore.push_application_key) {
	431	+ reject('Missing application key for Push because not supported');
	432	+ return;
	433	+ }
	434	+
	435	+ // check if a push subscription is available
	436	+ registration.pushManager.getSubscription().then((pushSubscription) => {
	437	+ if (pushSubscription) {
	438	+ // we are subscribed to Push
	439	+ let previous_endpoint = VBOCore.storageGetItem(VBOCore.push_storage_endpoint_id);
	440	+ if (previous_endpoint && pushSubscription.endpoint != previous_endpoint) {
	441	+ // update subscription data
	442	+ VBOCore.doAjax(
	443	+ VBOCore.options.push.ajax_url,
	444	+ VBOCore.buildPushSubscriptionData(pushSubscription, {
	445	+ agent: window.navigator.userAgent,
	446	+ type: 'update',
	447	+ })
	448	+ );
	449	+ }
	450	+
	451	+ // resolve the promise with the Push subscription data
	452	+ resolve(pushSubscription);
	453	+ return;
	454	+ }
	455	+
	456	+ // push subscription options
	457	+ const pushOptions = {
	458	+ userVisibleOnly: true,
	459	+ applicationServerKey: VBOCore.base64ToUint8Array(VBOCore.push_application_key),
	460	+ };
	461	+
	462	+ // subscribe to Push
	463	+ registration.pushManager.subscribe(pushOptions).then(
	464	+ (pushSubscription) => {
	465	+ // store subscription data
	466	+ VBOCore.storageSetItem(VBOCore.push_storage_endpoint_id, pushSubscription.endpoint);
	467	+ VBOCore.doAjax(
	468	+ VBOCore.options.push.ajax_url,
	469	+ VBOCore.buildPushSubscriptionData(pushSubscription, {
	470	+ agent: window.navigator.userAgent,
	471	+ type: 'new',
	472	+ })
	473	+ );
	474	+
	475	+ // resolve the promise with the Push subscription data
	476	+ resolve(pushSubscription);
	477	+ },
	478	+ (e) => {
	479	+ console.error(`Error handling the Push subscription state: ${e}`);
	480	+ reject('Error handling the Push subscription state');
	481	+ }
	482	+ );
	483	+ })
	484	+ .catch((e) => {
	485	+ console.error(`Error getting the Push subscription state: ${e}`);
	486	+ reject('Error getting the Push subscription state');
	487	+ });
	488	+ });
	489	+ }
	490	+
	491	+ /**
	492	+ * Starts listening to the "message" events posted by the ServiceWorker.
	493	+ *
	494	+ * @return void
	495	+ */
	496	+ static listenServiceWorkerMessages() {
	497	+ if (!('serviceWorker' in navigator)) {
	498	+ return;
	499	+ }
	500	+
	501	+ try {
	502	+ // add listener to the message event for the data posted by the ServiceWorker to the client
	503	+ navigator.serviceWorker.addEventListener('message', (event) => {
	504	+ VBOCore.handleServiceWorkerMessage(event.data);
	505	+ });
	506	+ } catch(e) {
	507	+ // do nothing
	508	+ }
	509	+ }
	510	+
	511	+ /**
	512	+ * Handles a message data posted by the ServiceWorker upon clicking a Push notification.
	513	+ *
	514	+ * @param object data the event.notification.data object posted by the ServiceWorker.
	515	+ *
	516	+ * @return void
	517	+ */
	518	+ static handleServiceWorkerMessage(data) {
	519	+ let notif_type = data.type || '';
	520	+
	521	+ if (!notif_type || !VBOCore.options.push_options.allowed_notif_types.includes(notif_type)) {
	522	+ console.error(data);
	523	+ throw new Error('Unsupported message type');
	524	+ }
	525	+
	526	+ // determine the proper widget for dispatching the message data
	527	+ let widget_id = 'booking_details';
	528	+ if (notif_type == 'Chat') {
	529	+ widget_id = 'guest_messages';
	530	+ }
	531	+
	532	+ // the raw notification content
	533	+ let raw_content = data.content || {};
	534	+
	535	+ // multitask data options
	536	+ let options = Object.assign({
	537	+ _push: 1,
	538	+ title: data.title || '',
	539	+ message: data.message || '',
	540	+ }, raw_content);
	541	+
	542	+ // dispatch (Push) message data on widget
	543	+ VBOCore.handleDisplayWidgetNotification({widget_id: widget_id}, options, true);
	544	+
	545	+ // update pushed data map for the next watching event in the current browsing context
	546	+ VBOCore.widgets_pushed_data.push(raw_content);
	547	+
	548	+ // post message onto broadcast channel for any other browsing context
	549	+ if (VBOCore.broadcast_push_data) {
	550	+ // the next watch-data interval will receive the pushed data information
	551	+ VBOCore.broadcast_push_data.postMessage(raw_content);
	552	+ }
	553	+
	554	+ // let the window reload the badge counter in case it must be updated
	555	+ VBOCore.emitEvent('vbo-badge-count-reload');
	556	+ }
	557	+
	558	+ /**
	559	+ * Ensures VBO is ready to support VCM.
	560	+ *
	561	+ * @param any env optional data to evaluate.
	562	+ *
	563	+ * @return bool
	564	+ */
	565	+ static vcmMultitasking(env) {
	566	+ // tell VCM that VBOCore supports it
	567	+ return true;
	568	+ }
	569	+
	570	+ /**
	571	+ * Registers an event identifier as delegated.
	572	+ * Useful to flag an event as registered.
	573	+ *
	574	+ * @param string ev The event name.
	575	+ *
	576	+ * @return Array
	577	+ */
	578	+ static setEventDelegated(ev) {
	579	+ VBOCore.options.events_delegated.push(ev);
	580	+ return VBOCore.options.events_delegated;
	581	+ }
	582	+
	583	+ /**
	584	+ * Un-registers an event identifier as delegated.
	585	+ *
	586	+ * @param string ev The event name.
	587	+ *
	588	+ * @return Array
	589	+ */
	590	+ static unsetEventDelegated(ev) {
	591	+ let index = VBOCore.options.events_delegated.indexOf(ev);
	592	+ if (index >= 0) {
	593	+ VBOCore.options.events_delegated.splice(index, 1);
	594	+ }
	595	+ return VBOCore.options.events_delegated;
	596	+ }
	597	+
	598	+ /**
	599	+ * Tells if an event identifier was delegated.
	600	+ *
	601	+ * @param string ev The event name.
	602	+ *
	603	+ * @return bool
	604	+ */
	605	+ static wasEventDelegated(ev) {
	606	+ return VBOCore.options.events_delegated.includes(ev);
	607	+ }
	608	+
	609	+ /**
	610	+ * Initializes the multitasking panel for the admin widgets.
	611	+ *
	612	+ * @param object params the panel object params.
	613	+ *
	614	+ * @return bool
	615	+ */
	616	+ static prepareMultitasking(params) {
	617	+ var panel_opts = {
	618	+ selector: "",
	619	+ sclass_l_small: "vbo-sidepanel-right",
	620	+ sclass_l_large: "vbo-sidepanel-large",
	621	+ btn_trigger: "",
	622	+ search_selector: "#vbo-sidepanel-search-input",
	623	+ search_nores: ".vbo-sidepanel-add-widgets-nores",
	624	+ close_selector: ".vbo-sidepanel-dismiss-btn",
	625	+ t_layout_small: ".vbo-sidepanel-layout-small",
	626	+ t_layout_large: ".vbo-sidepanel-layout-large",
	627	+ wclass_base_sel: ".vbo-admin-widgets-widget-output",
	628	+ wclass_l_small: "vbo-admin-widgets-container-small",
	629	+ wclass_l_large: "vbo-admin-widgets-container-large",
	630	+ addws_selector: ".vbo-sidepanel-add-widgets",
	631	+ addw_selector: ".vbo-sidepanel-add-widget",
	632	+ addw_modal_cls: "vbo-widget-render-modal",
	633	+ addw_def_cls: "vbo-widget-render-regular",
	634	+ addwfs_selector: ".vbo-sidepanel-add-widget-focussed",
	635	+ wtags_selector: ".vbo-sidepanel-widget-tags",
	636	+ wname_selector: ".vbo-sidepanel-widget-name",
	637	+ addw_data_attr: "data-vbowidgetid",
	638	+ actws_selector: ".vbo-sidepanel-active-widgets",
	639	+ editw_selector: ".vbo-sidepanel-edit-widgets-trig",
	640	+ shortc_selector: ".vbo-sidepanel-shortcut",
	641	+ rmwidget_class: "vbo-admin-widgets-widget-remove",
	642	+ rmwidget_icn: "",
	643	+ dtcwidget_class: "vbo-admin-widgets-widget-detach",
	644	+ dtctarget_class: "vbo-admin-widget-head",
	645	+ dtcwidget_icn: "",
	646	+ notif_selector: ".vbo-sidepanel-notifications-btn",
	647	+ notif_on_class: "vbo-sidepanel-notifications-on",
	648	+ notif_off_class: "vbo-sidepanel-notifications-off",
	649	+ open_class: "vbo-sidepanel-open",
	650	+ close_class: "vbo-sidepanel-close",
	651	+ cur_widget_cls: "vbo-admin-widgets-container-small",
	652	+ sortable: true,
	653	+ sort_save_ev: "vbo-admin-widgets-updateposmp",
	654	+ sorting: null,
	655	+ };
	656	+
	657	+ if (typeof params === 'object') {
	658	+ panel_opts = Object.assign(panel_opts, params);
	659	+ }
	660	+
	661	+ if (!panel_opts.btn_trigger || !panel_opts.selector) {
	662	+ console.error('Got no trigger or selector');
	663	+ return false;
	664	+ }
	665	+
	666	+ // push panel options
	667	+ VBOCore.setOptions({
	668	+ panel_opts: panel_opts,
	669	+ });
	670	+
	671	+ if (VBOCore.options.is_vbo) {
	672	+ // setup browser notifications
	673	+ VBOCore.setupNotifications();
	674	+ }
	675	+
	676	+ // count active widgets on current page
	677	+ var tot_active_widgets = VBOCore.options.admin_widgets.length;
	678	+ if (tot_active_widgets > 0) {
	679	+ // hide add-widgets container
	680	+ $(panel_opts.addws_selector).hide();
	681	+
	682	+ // register listener for input search blur
	683	+ VBOCore.registerSearchWidgetsBlur();
	684	+ }
	685	+
	686	+ // register click event on trigger button
	687	+ $(VBOCore.options.panel_opts.btn_trigger).on('click', function() {
	688	+ var side_panel = $(VBOCore.options.panel_opts.selector);
	689	+ if (side_panel.hasClass(VBOCore.options.panel_opts.open_class)) {
	690	+ // hide panel
	691	+ VBOCore.side_panel_on = false;
	692	+ VBOCore.emitMultitaskEvent(VBOCore.multitask_close_event);
	693	+ side_panel.addClass(VBOCore.options.panel_opts.close_class).removeClass(VBOCore.options.panel_opts.open_class);
	694	+ // always hide add-widgets container
	695	+ $(VBOCore.options.panel_opts.addws_selector).hide();
	696	+ // check if we are currently editing
	697	+ var is_editing = ($('.' + VBOCore.options.panel_opts.editmode_class).length > 0);
	698	+ if (is_editing) {
	699	+ // deactivate editing mode
	700	+ VBOCore.toggleWidgetsPanelEditing(null);
	701	+ }
	702	+ } else {
	703	+ // show panel
	704	+ VBOCore.side_panel_on = true;
	705	+ VBOCore.emitMultitaskEvent(VBOCore.multitask_open_event);
	706	+ side_panel.addClass(VBOCore.options.panel_opts.open_class).removeClass(VBOCore.options.panel_opts.close_class);
	707	+ if (!VBOCore.options.admin_widgets.length) {
	708	+ // set focus on search widgets input with delay for the opening animation
	709	+ setTimeout(function() {
	710	+ $(VBOCore.options.panel_opts.search_selector).focus();
	711	+ }, 300);
	712	+ }
	713	+ }
	714	+ });
	715	+
	716	+ // register close/dismiss button
	717	+ $(VBOCore.options.panel_opts.close_selector).on('click', function() {
	718	+ $(VBOCore.options.panel_opts.btn_trigger).trigger('click');
	719	+ });
	720	+
	721	+ if (VBOCore.options.is_vbo) {
	722	+ // register toggle layout buttons
	723	+ $(VBOCore.options.panel_opts.t_layout_large).on('click', function() {
	724	+ // large layout
	725	+ $(VBOCore.options.panel_opts.selector).addClass(VBOCore.options.panel_opts.sclass_l_large).removeClass(VBOCore.options.panel_opts.sclass_l_small);
	726	+ $(VBOCore.options.panel_opts.wclass_base_sel).addClass(VBOCore.options.panel_opts.wclass_l_large).removeClass(VBOCore.options.panel_opts.wclass_l_small);
	727	+ VBOCore.options.panel_opts.cur_widget_cls = VBOCore.options.panel_opts.sclass_l_large;
	728	+ });
	729	+ $(VBOCore.options.panel_opts.t_layout_small).on('click', function() {
	730	+ // small layout
	731	+ $(VBOCore.options.panel_opts.selector).addClass(VBOCore.options.panel_opts.sclass_l_small).removeClass(VBOCore.options.panel_opts.sclass_l_large);
	732	+ $(VBOCore.options.panel_opts.wclass_base_sel).addClass(VBOCore.options.panel_opts.wclass_l_small).removeClass(VBOCore.options.panel_opts.wclass_l_large);
	733	+ VBOCore.options.panel_opts.cur_widget_cls = VBOCore.options.panel_opts.sclass_l_small;
	734	+ });
	735	+ }
	736	+
	737	+ // register listener for esc key pressed
	738	+ $(document).keyup(function(e) {
	739	+ if (!VBOCore.side_panel_on) {
	740	+ return;
	741	+ }
	742	+ if ((e.key && e.key === "Escape") || (e.keyCode && e.keyCode == 27)) {
	743	+ $(VBOCore.options.panel_opts.btn_trigger).trigger('click');
	744	+ }
	745	+ });
	746	+
	747	+ // register listener for input search focus
	748	+ $(VBOCore.options.panel_opts.search_selector).on('focus', function() {
	749	+ // always show add-widgets container
	750	+ var widget_focus_class = VBOCore.options.panel_opts.addwfs_selector.replace('.', '');
	751	+ $(VBOCore.options.panel_opts.addw_selector).removeClass(widget_focus_class);
	752	+ $(VBOCore.options.panel_opts.addws_selector).show();
	753	+ });
	754	+
	755	+ // register listener on input search widget
	756	+ $(VBOCore.options.panel_opts.search_selector).keyup(function(e) {
	757	+ // get the keyword to look for
	758	+ var keyword = $(this).val();
	759	+ // counting matching widgets
	760	+ var matching = 0;
	761	+ var first_matched = null;
	762	+ var widget_focus_class = VBOCore.options.panel_opts.addwfs_selector.replace('.', '');
	763	+
	764	+ // adjust widgets to be displayed
	765	+ if (!keyword.length) {
	766	+ // show all widgets for selection
	767	+ $(VBOCore.options.panel_opts.addw_selector).show();
	768	+ // hide "no results"
	769	+ $(VBOCore.options.panel_opts.search_nores).hide();
	770	+ // all widgets are matching
	771	+ matching = $(VBOCore.options.panel_opts.addw_selector).length;
	772	+ } else {
	773	+ // make the keyword lowercase
	774	+ keyword = (keyword + '').toLowerCase();
	775	+ // parse all widget's description tags
	776	+ $(VBOCore.options.panel_opts.addw_selector).each(function() {
	777	+ var elem = $(this);
	778	+ var descr = elem.find(VBOCore.options.panel_opts.wtags_selector).text();
	779	+ if (VBOCore.matchString(keyword, descr)) {
	780	+ elem.show();
	781	+ matching++;
	782	+ if (!first_matched) {
	783	+ // store the first widget that matched
	784	+ first_matched = elem.attr(VBOCore.options.panel_opts.addw_data_attr);
	785	+ }
	786	+ } else {
	787	+ elem.hide();
	788	+ }
	789	+ });
	790	+ // check how many widget matched
	791	+ if (matching > 0) {
	792	+ // hide "no results"
	793	+ $(VBOCore.options.panel_opts.search_nores).hide();
	794	+ } else {
	795	+ // show "no results"
	796	+ $(VBOCore.options.panel_opts.search_nores).show();
	797	+ }
	798	+ }
	799	+
	800	+ // check for shortcuts
	801	+ if (!e.key) {
	802	+ return;
	803	+ }
	804	+
	805	+ // handle Enter key press to add a widget
	806	+ if (e.key === "Enter") {
	807	+ // on Enter key pressed, open/add the first matching widget or the focussed one
	808	+ var load_wid_id = null;
	809	+ var focussed_wid = $(VBOCore.options.panel_opts.addwfs_selector + ':visible').first();
	810	+
	811	+ if (focussed_wid.length) {
	812	+ load_wid_id = focussed_wid.attr(VBOCore.options.panel_opts.addw_data_attr);
	813	+ } else if (first_matched) {
	814	+ load_wid_id = first_matched;
	815	+ }
	816	+
	817	+ if (!load_wid_id) {
	818	+ // no widget to render found
	819	+ return;
	820	+ }
	821	+
	822	+ if (e.shiftKey === true && !VBOCore.options.is_vcm) {
	823	+ // widget multitask panel rendering
	824	+ VBOCore.addWidgetToPanel(load_wid_id);
	825	+ $(VBOCore.options.panel_opts.search_selector).trigger('blur');
	826	+
	827	+ return;
	828	+ }
	829	+
	830	+ // widget modal rendering is the default method
	831	+ if (VBOCore.options.is_vcm) {
	832	+ // register loading effect with automatic cancellation
	833	+ let orig_name = (focussed_wid.length ? focussed_wid : first_matched).find(VBOCore.options.panel_opts.wname_selector).text();
	834	+ (focussed_wid.length ? focussed_wid : first_matched).find(VBOCore.options.panel_opts.wname_selector).html(orig_name + ' ' + VBOCore.options.default_loading_body);
	835	+ setTimeout(() => {
	836	+ (focussed_wid.length ? focussed_wid : first_matched).find(VBOCore.options.panel_opts.wname_selector).text(orig_name);
	837	+ }, 1000);
	838	+
	839	+ // assets will be loaded within VCM before rendering the modal widget
	840	+ VBOCore.handleDisplayWidgetNotification({widget_id: load_wid_id});
	841	+ } else {
	842	+ VBOCore.renderModalWidget(load_wid_id);
	843	+ }
	844	+
	845	+ return;
	846	+ }
	847	+
	848	+ // handle arrow keys selection
	849	+ if (matching > 0 && (e.key === 'ArrowDown' || e.key === 'ArrowUp')) {
	850	+ // on arrow key pressed, select the next or prev widget
	851	+ var addws_element = $(VBOCore.options.panel_opts.addws_selector);
	852	+ var addws_cont_pos = addws_element.offset().top;
	853	+ var addws_otheight = addws_element.outerHeight();
	854	+ var addws_scrolltp = addws_element.scrollTop();
	855	+
	856	+ if (e.key === 'ArrowDown') {
	857	+ var default_widg = $(VBOCore.options.panel_opts.addw_selector + ':visible').first();
	858	+ } else {
	859	+ var default_widg = $(VBOCore.options.panel_opts.addw_selector + ':visible').last();
	860	+ }
	861	+ var focussed_wid = $(VBOCore.options.panel_opts.addwfs_selector + ':visible').first();
	862	+ var addw_height = default_widg.outerHeight();
	863	+ var focussed_pos = default_widg.offset().top + addw_height;
	864	+
	865	+ if (focussed_wid.length) {
	866	+ focussed_wid.removeClass(widget_focus_class);
	867	+ if (e.key === 'ArrowDown') {
	868	+ var goto_wid = focussed_wid.nextAll(VBOCore.options.panel_opts.addw_selector + ':visible').first();
	869	+ } else {
	870	+ var goto_wid = focussed_wid.prevAll(VBOCore.options.panel_opts.addw_selector + ':visible').first();
	871	+ }
	872	+ if (goto_wid.length) {
	873	+ goto_wid.addClass(widget_focus_class);
	874	+ focussed_pos = goto_wid.offset().top + addw_height;
	875	+ } else {
	876	+ default_widg.addClass(widget_focus_class);
	877	+ }
	878	+ } else {
	879	+ default_widg.addClass(widget_focus_class);
	880	+ }
	881	+
	882	+ if (focussed_pos > (addws_cont_pos + addws_otheight)) {
	883	+ addws_element.scrollTop(focussed_pos - addws_cont_pos - addw_height + addws_scrolltp);
	884	+ } else if (focussed_pos < 0) {
	885	+ addws_element.scrollTop(0);
	886	+ }
	887	+ }
	888	+ });
	889	+
	890	+ // register listener for adding widgets
	891	+ $(VBOCore.options.panel_opts.addw_selector).on('click', function(e) {
	892	+ var widget_id = $(this).attr(VBOCore.options.panel_opts.addw_data_attr);
	893	+ if (!widget_id || !widget_id.length) {
	894	+ return false;
	895	+ }
	896	+
	897	+ if (VBOCore.options.panel_opts.sorting) {
	898	+ // prevent dropped widgets after sorting to be added to the panel
	899	+ return false;
	900	+ }
	901	+
	902	+ // determine widget rendering method
	903	+ if (e && e.target) {
	904	+ let cktarget = $(e.target);
	905	+ let is_main_elem_clicked = cktarget.length && (cktarget.hasClass('vbo-sidepanel-widget-info-det') || cktarget.hasClass('vbo-sidepanel-widget-name'));
	906	+ if (e.shiftKey === true || VBOCore.options.is_vcm || is_main_elem_clicked || (cktarget.hasClass(VBOCore.options.panel_opts.addw_modal_cls) || cktarget.parent().hasClass(VBOCore.options.panel_opts.addw_modal_cls))) {
	907	+ // widget modal rendering
	908	+ if (VBOCore.options.is_vcm) {
	909	+ // register loading effect with automatic cancellation
	910	+ let orig_name = $(this).find(VBOCore.options.panel_opts.wname_selector).text();
	911	+ $(this).find(VBOCore.options.panel_opts.wname_selector).html(orig_name + ' ' + VBOCore.options.default_loading_body);
	912	+ setTimeout(() => {
	913	+ $(this).find(VBOCore.options.panel_opts.wname_selector).text(orig_name);
	914	+ }, 1000);
	915	+
	916	+ // assets will be loaded within VCM before rendering the modal widget
	917	+ VBOCore.handleDisplayWidgetNotification({widget_id: widget_id});
	918	+ } else {
	919	+ VBOCore.renderModalWidget(widget_id);
	920	+ }
	921	+
	922	+ return;
	923	+ }
	924	+ }
	925	+
	926	+ // widget multitask panel rendering
	927	+ VBOCore.addWidgetToPanel(widget_id);
	928	+ });
	929	+
	930	+ if (VBOCore.options.is_vbo) {
	931	+ // register listener for updating multitask sidepanel with debounce
	932	+ document.addEventListener(VBOCore.options.multitask_save_event, VBOCore.debounceEvent(VBOCore.saveMultitasking, 1000));
	933	+ }
	934	+
	935	+ // subscribe to event for multitask shortcut
	936	+ document.addEventListener(VBOCore.multitask_shortcut_event, function() {
	937	+ // toggle multitask panel
	938	+ $(VBOCore.options.panel_opts.btn_trigger).trigger('click');
	939	+ });
	940	+
	941	+ // subscribe to event for multitask search focus shortcut
	942	+ document.addEventListener(VBOCore.multitask_searchfs_event, function() {
	943	+ // focus search multitask widgets
	944	+ $(VBOCore.options.panel_opts.search_selector).trigger('focus');
	945	+ });
	946	+
	947	+ if (VBOCore.options.is_vbo) {
	948	+ // register click event on edit widgets button
	949	+ $(VBOCore.options.panel_opts.editw_selector).on('click', function() {
	950	+ VBOCore.toggleWidgetsPanelEditing(null);
	951	+ });
	952	+
	953	+ // register detach widget buttons
	954	+ $('.' + VBOCore.options.panel_opts.dtcwidget_class).each(function() {
	955	+ let widget_wrapper = $(this).parent(VBOCore.options.panel_opts.wclass_base_sel);
	956	+ let detach_widget_id = widget_wrapper.attr(VBOCore.options.panel_opts.addw_data_attr);
	957	+ let detach_to_target = widget_wrapper.find('.' + VBOCore.options.panel_opts.dtctarget_class);
	958	+ if (!detach_to_target.length) {
	959	+ detach_to_target = widget_wrapper;
	960	+ }
	961	+ // move detach wrapper onto the target (widget head)
	962	+ $(this).prependTo(detach_to_target);
	963	+
	964	+ if (!detach_widget_id) {
	965	+ return;
	966	+ }
	967	+
	968	+ // register detach action
	969	+ $(this).on('click', function() {
	970	+ // detach widget, meaning do a modal rendering
	971	+ VBOCore.renderModalWidget(detach_widget_id);
	972	+ });
	973	+ });
	974	+ }
	975	+
	976	+ if (VBOCore.options.panel_opts.sortable && typeof $.fn.sortable !== 'undefined') {
	977	+ // make the admin widgets sortable
	978	+ let sortable_env = VBOCore.options.is_vcm ? 'vcm-sidepanel-add-widgets' : 'vbo-sidepanel-add-widgets';
	979	+ let handle_env = VBOCore.options.is_vcm ? 'vcm-sidepanel-widget-info-det' : 'vbo-sidepanel-widget-info-det';
	980	+ let item_env = VBOCore.options.is_vcm ? 'vcm-sidepanel-add-widget' : 'vbo-sidepanel-add-widget';
	981	+
	982	+ // default sorting flag
	983	+ VBOCore.options.panel_opts.sorting = null;
	984	+
	985	+ // register listener for updating the widget sorting values on the multitask sidepanel with debounce
	986	+ document.addEventListener(VBOCore.options.panel_opts.sort_save_ev, VBOCore.debounceEvent(VBOCore.saveMultitaskingSorting, 500));
	987	+
	988	+ // apply sorting capabilities
	989	+ $('.' + sortable_env).sortable({
	990	+ axix: 'x',
	991	+ cursor: 'move',
	992	+ handle: '.' + handle_env,
	993	+ items: '.' + item_env,
	994	+ containment: 'parent',
	995	+ revert: false,
	996	+ start: function(event, ui) {
	997	+ // update flag
	998	+ VBOCore.options.panel_opts.sorting = $(ui.item).attr('data-vbowidgetid');
	999	+ // set is-sorting class
	1000	+ $(ui.item).addClass('is-sorting');
	1001	+ },
	1002	+ stop: function(event, ui) {
	1003	+ // make sure no elements are being sorted
	1004	+ $('.' + item_env).removeClass('is-sorting');
	1005	+ // register delayed update flag to allow understanding a sorting was just completed
	1006	+ setTimeout(() => {
	1007	+ // restore default sorting flag
	1008	+ VBOCore.options.panel_opts.sorting = null;
	1009	+ }, 500);
	1010	+ },
	1011	+ update: function(event, ui) {
	1012	+ // build the current widgets position list
	1013	+ let pos_list = {};
	1014	+ document.querySelectorAll('.' + item_env).forEach((elem, index) => {
	1015	+ let curr_wid = elem.getAttribute('data-vbowidgetid');
	1016	+ pos_list[curr_wid] = index;
	1017	+ });
	1018	+ // trigger the event to update the widget positions
	1019	+ VBOCore.emitEvent(VBOCore.options.panel_opts.sort_save_ev, {
	1020	+ pos_list: pos_list,
	1021	+ });
	1022	+ }
	1023	+ });
	1024	+ }
	1025	+ }
	1026	+
	1027	+ /**
	1028	+ * Registers the callback for saving the new widget sorting value in the Multitask panel.
	1029	+ */
	1030	+ static saveMultitaskingSorting(e) {
	1031	+ if (!e || !e.detail || !e.detail.pos_list) {
	1032	+ return;
	1033	+ }
	1034	+
	1035	+ // update multitask widget position
	1036	+ VBOCore.doAjax(
	1037	+ VBOCore.options.multitask_ajax_uri,
	1038	+ {
	1039	+ call: 'setMultitaskingWidgetPos',
	1040	+ call_args: [
	1041	+ e.detail.pos_list,
	1042	+ ],
	1043	+ },
	1044	+ (response) => {
	1045	+ // do nothing on success
	1046	+ },
	1047	+ (error) => {
	1048	+ // silently log the error
	1049	+ console.error(error.responseText);
	1050	+ }
	1051	+ );
	1052	+ }
	1053	+
	1054	+ /**
	1055	+ * Registers the blur event for the search widgets input.
	1056	+ */
	1057	+ static registerSearchWidgetsBlur() {
	1058	+ if (VBOCore.options.active_listeners.hasOwnProperty('registerSearchWidgetsBlur')) {
	1059	+ // listener is already registered
	1060	+ return true;
	1061	+ }
	1062	+
	1063	+ $(VBOCore.options.panel_opts.search_selector).on('blur', function(e) {
	1064	+ if (e && e.relatedTarget) {
	1065	+ if (e.relatedTarget.classList.contains(VBOCore.options.panel_opts.addw_selector.replace('.', ''))) {
	1066	+ // add new widget was clicked, abort hiding process or click event won't fire on target element
	1067	+ return;
	1068	+ }
	1069	+ }
	1070	+ var keyword = $(this).val();
	1071	+ if (!keyword.length) {
	1072	+ // hide add-widgets container
	1073	+ $(VBOCore.options.panel_opts.addws_selector).hide();
	1074	+ }
	1075	+ });
	1076	+
	1077	+ // register flag for listener active
	1078	+ VBOCore.options.active_listeners['registerSearchWidgetsBlur'] = 1;
	1079	+ }
	1080	+
	1081	+ /**
	1082	+ * Removes the blur event handler for the search widgets input.
	1083	+ */
	1084	+ static unregisterSearchWidgetsBlur() {
	1085	+ if (!VBOCore.options.active_listeners.hasOwnProperty('registerSearchWidgetsBlur')) {
	1086	+ // nothing to unregister
	1087	+ return true;
	1088	+ }
	1089	+
	1090	+ $(VBOCore.options.panel_opts.search_selector).off('blur');
	1091	+
	1092	+ // delete flag for listener active
	1093	+ delete VBOCore.options.active_listeners['registerSearchWidgetsBlur'];
	1094	+ }
	1095	+
	1096	+ /**
	1097	+ * Adds a widget identifier to the multitask panel.
	1098	+ *
	1099	+ * @param string widget_id the widget identifier string to add.
	1100	+ */
	1101	+ static addWidgetToPanel(widget_id) {
	1102	+ if (!VBOCore.options.widget_ajax_uri || !VBOCore.options.panel_opts || !Object.keys(VBOCore.options.panel_opts).length) {
	1103	+ throw new Error('Multitask panel options are missing');
	1104	+ }
	1105	+ // prepend container to panel
	1106	+ var widget_classes = [VBOCore.options.panel_opts.wclass_base_sel.replace('.', ''), VBOCore.options.panel_opts.cur_widget_cls];
	1107	+ var widget_div = '<div class="' + widget_classes.join(' ') + '" ' + VBOCore.options.panel_opts.addw_data_attr + '="' + widget_id + '" style="display: none;"></div>';
	1108	+ var widget_elem = $(widget_div);
	1109	+ $(VBOCore.options.panel_opts.actws_selector).prepend(widget_elem);
	1110	+
	1111	+ // always hide add-widgets container
	1112	+ $(VBOCore.options.panel_opts.addws_selector).hide();
	1113	+
	1114	+ // trigger debounced map saving event
	1115	+ VBOCore.emitMultitaskEvent();
	1116	+
	1117	+ // register listener for input search blur
	1118	+ VBOCore.registerSearchWidgetsBlur();
	1119	+
	1120	+ // render widget
	1121	+ var call_method = 'render';
	1122	+ VBOCore.doAjax(
	1123	+ VBOCore.options.widget_ajax_uri,
	1124	+ {
	1125	+ widget_id: widget_id,
	1126	+ call: call_method,
	1127	+ vbo_page: VBOCore.options.current_page,
	1128	+ vbo_uri: VBOCore.options.current_page_uri,
	1129	+ multitask: 1,
	1130	+ },
	1131	+ (response) => {
	1132	+ // display widgets editing button
	1133	+ VBOCore.toggleWidgetsPanelEditing(true);
	1134	+ // parse response
	1135	+ try {
	1136	+ var obj_res = typeof response === 'string' ? JSON.parse(response) : response;
	1137	+ if (obj_res.hasOwnProperty(call_method)) {
	1138	+ // populate widget HTML content and display it
	1139	+ widget_elem.html(obj_res[call_method]).fadeIn();
	1140	+
	1141	+ // always scroll active widgets list to top
	1142	+ $(VBOCore.options.panel_opts.actws_selector).scrollTop(0);
	1143	+
	1144	+ // register detach widget button
	1145	+ setTimeout(() => {
	1146	+ let detach_elem = $('<div></div>').addClass(VBOCore.options.panel_opts.dtcwidget_class).html(VBOCore.options.panel_opts.dtcwidget_icn);
	1147	+ let detach_to_target = widget_elem.find('.' + VBOCore.options.panel_opts.dtctarget_class);
	1148	+ if (!detach_to_target.length) {
	1149	+ detach_to_target = widget_elem;
	1150	+ }
	1151	+ // move detach wrapper onto the target (widget head)
	1152	+ detach_elem.prependTo(detach_to_target);
	1153	+ // register detach action
	1154	+ detach_elem.on('click', function() {
	1155	+ // detach widget, meaning do a modal rendering
	1156	+ VBOCore.renderModalWidget(widget_id);
	1157	+ });
	1158	+ }, 500);
	1159	+ } else {
	1160	+ console.error('Unexpected JSON response', obj_res);
	1161	+ }
	1162	+ } catch(err) {
	1163	+ console.error('could not parse JSON response', err, response);
	1164	+ }
	1165	+ },
	1166	+ (error) => {
	1167	+ console.error(error.responseText);
	1168	+ }
	1169	+ );
	1170	+ }
	1171	+
	1172	+ /**
	1173	+ * Toggles the edit mode of the multitask widgets panel.
	1174	+ *
	1175	+ * @param bool added true if a widget was just added, false if it was just removed.
	1176	+ */
	1177	+ static toggleWidgetsPanelEditing(added) {
	1178	+ // check if we are currently editing
	1179	+ var is_editing = ($('.' + VBOCore.options.panel_opts.editmode_class).length > 0);
	1180	+
	1181	+ // the triggerer button
	1182	+ var triggerer = $(VBOCore.options.panel_opts.editw_selector);
	1183	+
	1184	+ // check added action status
	1185	+ if (added === true) {
	1186	+ // show button for edit mode
	1187	+ triggerer.show();
	1188	+ // hide shortcut element
	1189	+ $(VBOCore.options.panel_opts.shortc_selector).hide();
	1190	+ return;
	1191	+ }
	1192	+
	1193	+ // grab all widgets
	1194	+ var editing_widgets = $(VBOCore.options.panel_opts.wclass_base_sel);
	1195	+
	1196	+ if (added === false) {
	1197	+ if (!editing_widgets.length) {
	1198	+ // hide button for edit mode after removing the last widget
	1199	+ triggerer.removeClass(VBOCore.options.panel_opts.editw_selector.substr(1) + '-active').hide();
	1200	+ // show shortcut element
	1201	+ $(VBOCore.options.panel_opts.shortc_selector).show();
	1202	+ }
	1203	+ return;
	1204	+ }
	1205	+
	1206	+ if (is_editing) {
	1207	+ // deactivate editing mode
	1208	+ editing_widgets.removeClass(VBOCore.options.panel_opts.editmode_class);
	1209	+ $('.' + VBOCore.options.panel_opts.rmwidget_class).remove();
	1210	+ // toggle triggerer button active class
	1211	+ triggerer.removeClass(VBOCore.options.panel_opts.editw_selector.substr(1) + '-active');
	1212	+ } else {
	1213	+ // activate editing mode by looping through all widgets
	1214	+ editing_widgets.each(function() {
	1215	+ // build remove-widget element
	1216	+ var rm_widget = $('<div></div>').addClass(VBOCore.options.panel_opts.rmwidget_class).on('click', function() {
	1217	+ VBOCore.removeWidgetFromPanel(this);
	1218	+ }).html(VBOCore.options.panel_opts.rmwidget_icn);
	1219	+ // add editing class and prepend removing element
	1220	+ $(this).addClass(VBOCore.options.panel_opts.editmode_class).prepend(rm_widget);
	1221	+ });
	1222	+ // toggle triggerer button active class
	1223	+ triggerer.addClass(VBOCore.options.panel_opts.editw_selector.substr(1) + '-active');
	1224	+ }
	1225	+ }
	1226	+
	1227	+ /**
	1228	+ * Handles the removal of a widget from the multitask panel.
	1229	+ *
	1230	+ * @param object element
	1231	+ */
	1232	+ static removeWidgetFromPanel(element) {
	1233	+ if (!element) {
	1234	+ console.error('Invalid widget element to remove', element);
	1235	+ return false;
	1236	+ }
	1237	+ var widget_cont = $(element).parent(VBOCore.options.panel_opts.wclass_base_sel);
	1238	+ if (!widget_cont || !widget_cont.length) {
	1239	+ console.error('Could not find widget container to remove', element);
	1240	+ return false;
	1241	+ }
	1242	+ var widget_id = widget_cont.attr(VBOCore.options.panel_opts.addw_data_attr);
	1243	+ if (!widget_id || !widget_id.length) {
	1244	+ console.error('Empty widget id to remove', element);
	1245	+ return false;
	1246	+ }
	1247	+ // find the index of the widget to remove in the panel
	1248	+ var widget_index = $(VBOCore.options.panel_opts.wclass_base_sel).index(widget_cont);
	1249	+ if (widget_index < 0) {
	1250	+ console.error('Empty widget index to remove', widget_cont);
	1251	+ return false;
	1252	+ }
	1253	+ // make sure the index in the array matches the id
	1254	+ if (!VBOCore.options.admin_widgets.hasOwnProperty(widget_index) || VBOCore.options.admin_widgets[widget_index]['id'] != widget_id) {
	1255	+ console.error('Unmatching widget index or id', VBOCore.options.admin_widgets, widget_index, widget_id);
	1256	+ return false;
	1257	+ }
	1258	+ // remove this widget from the array
	1259	+ VBOCore.options.admin_widgets.splice(widget_index, 1);
	1260	+
	1261	+ // remove element from document
	1262	+ widget_cont.remove();
	1263	+
	1264	+ // check widgets editing button status
	1265	+ VBOCore.toggleWidgetsPanelEditing(false);
	1266	+
	1267	+ // trigger debounced map saving event
	1268	+ VBOCore.emitMultitaskEvent();
	1269	+
	1270	+ if (!VBOCore.options.admin_widgets.length) {
	1271	+ // unregister listener for input search blur
	1272	+ VBOCore.unregisterSearchWidgetsBlur();
	1273	+ }
	1274	+ }
	1275	+
	1276	+ /**
	1277	+ * Emits an event related to the multitask features or a custom event, with optional data.
	1278	+ */
	1279	+ static emitMultitaskEvent(ev_name, ev_data) {
	1280	+ var def_ev_name = VBOCore.options.multitask_save_event;
	1281	+ if (typeof ev_name === 'string') {
	1282	+ def_ev_name = ev_name;
	1283	+ }
	1284	+
	1285	+ if (typeof ev_data !== 'undefined' && ev_data) {
	1286	+ // trigger the custom event
	1287	+ document.dispatchEvent(new CustomEvent(def_ev_name, {bubbles: true, detail: ev_data}));
	1288	+ return;
	1289	+ }
	1290	+
	1291	+ // trigger the event
	1292	+ document.dispatchEvent(new Event(def_ev_name));
	1293	+ }
	1294	+
	1295	+ /**
	1296	+ * Proxy for dispatching an event to the document with optional data.
	1297	+ */
	1298	+ static emitEvent(ev_name, ev_data) {
	1299	+ if (typeof ev_name !== 'string' || !ev_name.length) {
	1300	+ return;
	1301	+ }
	1302	+
	1303	+ return VBOCore.emitMultitaskEvent(ev_name, ev_data);
	1304	+ }
	1305	+
	1306	+ /**
	1307	+ * Attempts to save the multitask widgets for this page.
	1308	+ */
	1309	+ static saveMultitasking() {
	1310	+ // gather the list of active widgets
	1311	+ var active_widgets = [];
	1312	+ var cur_admin_widgets = [];
	1313	+ $(VBOCore.options.panel_opts.actws_selector).find(VBOCore.options.panel_opts.wclass_base_sel).each(function() {
	1314	+ var widget_id = $(this).attr(VBOCore.options.panel_opts.addw_data_attr);
	1315	+ if (widget_id && widget_id.length) {
	1316	+ // push id in list
	1317	+ active_widgets.push(widget_id);
	1318	+ // push object with dummy name for global widgets
	1319	+ cur_admin_widgets.push({
	1320	+ id: widget_id,
	1321	+ name: widget_id,
	1322	+ });
	1323	+ }
	1324	+ });
	1325	+
	1326	+ // update multitask widgets map for this page
	1327	+ VBOCore.doAjax(
	1328	+ VBOCore.options.multitask_ajax_uri,
	1329	+ {
	1330	+ call: 'updateMultitaskingMap',
	1331	+ call_args: [
	1332	+ VBOCore.options.current_page,
	1333	+ active_widgets,
	1334	+ 0
	1335	+ ],
	1336	+ },
	1337	+ (response) => {
	1338	+ try {
	1339	+ var obj_res = typeof response === 'string' ? JSON.parse(response) : response;
	1340	+ if (obj_res.hasOwnProperty('result') && obj_res['result']) {
	1341	+ // set current widgets
	1342	+ VBOCore.setOptions({
	1343	+ admin_widgets: cur_admin_widgets
	1344	+ });
	1345	+ } else {
	1346	+ console.error('Unexpected or invalid JSON response', response);
	1347	+ }
	1348	+ } catch(err) {
	1349	+ console.error('could not parse JSON response', err, response);
	1350	+ }
	1351	+ },
	1352	+ (error) => {
	1353	+ console.error(error.responseText);
	1354	+ }
	1355	+ );
	1356	+ }
	1357	+
	1358	+ /**
	1359	+ * Sets up the browser notifications within the multitask panel, if supported.
	1360	+ */
	1361	+ static setupNotifications() {
	1362	+ if (!('Notification' in window)) {
	1363	+ // browser does not support notifications
	1364	+ $(VBOCore.options.panel_opts.notif_selector).hide();
	1365	+ return false;
	1366	+ }
	1367	+
	1368	+ if (Notification.permission && Notification.permission === 'granted') {
	1369	+ // permissions were granted already
	1370	+ $(VBOCore.options.panel_opts.notif_selector)
	1371	+ .addClass(VBOCore.options.panel_opts.notif_on_class)
	1372	+ .attr('title', VBOCore.options.tn_texts.notifs_enabled)
	1373	+ .on('click', function() {
	1374	+ // show congratulations notification
	1375	+ VBOCore.dispatchCongratulations();
	1376	+
	1377	+ // attempt to update the service worker installation
	1378	+ VBOCore.installServiceWorker(true).then(() => {
	1379	+ // all good
	1380	+ }).catch((error) => {
	1381	+ console.error(error);
	1382	+ });
	1383	+ });
	1384	+ return true;
	1385	+ }
	1386	+
	1387	+ // notifications supported, but perms not granted
	1388	+ $(VBOCore.options.panel_opts.notif_selector)
	1389	+ .addClass(VBOCore.options.panel_opts.notif_off_class)
	1390	+ .attr('title', VBOCore.options.tn_texts.notifs_disabled);
	1391	+
	1392	+ // register click-event listener on button to enable notifications
	1393	+ $(VBOCore.options.panel_opts.notif_selector).on('click', function() {
	1394	+ VBOCore.requestNotifPerms();
	1395	+ });
	1396	+
	1397	+ // subscribe to the multitask-panel-open event to show the status of the notifications
	1398	+ document.addEventListener(VBOCore.multitask_open_event, function() {
	1399	+ if (VBOCore.notificationsEnabled() === false) {
	1400	+ // add "shaking" class to notifications button
	1401	+ $(VBOCore.options.panel_opts.notif_selector).addClass('shaking');
	1402	+ }
	1403	+ });
	1404	+
	1405	+ // subscribe to the multitask-panel-close event to update the status of the notifications
	1406	+ document.addEventListener(VBOCore.multitask_close_event, function() {
	1407	+ // always remove "shaking" class from notifications button
	1408	+ $(VBOCore.options.panel_opts.notif_selector).removeClass('shaking');
	1409	+ });
	1410	+ }
	1411	+
	1412	+ /**
	1413	+ * Sets up the browser notifications within the given selector, if supported.
	1414	+ *
	1415	+ * @param string selector the element query selector.
	1416	+ */
	1417	+ static suggestNotifications(selector) {
	1418	+ if (!selector) {
	1419	+ return false;
	1420	+ }
	1421	+
	1422	+ if (!('Notification' in window)) {
	1423	+ // browser does not support notifications
	1424	+ $(selector).hide();
	1425	+ return false;
	1426	+ }
	1427	+
	1428	+ if (Notification.permission && Notification.permission === 'granted') {
	1429	+ // permissions were granted already
	1430	+ $(selector)
	1431	+ .addClass(VBOCore.options.panel_opts.notif_on_class)
	1432	+ .attr('title', VBOCore.options.tn_texts.notifs_enabled)
	1433	+ .on('click', function() {
	1434	+ VBOCore.dispatchCongratulations();
	1435	+ });
	1436	+ return true;
	1437	+ }
	1438	+
	1439	+ // notifications supported, but perms not granted
	1440	+ $(selector)
	1441	+ .addClass(VBOCore.options.panel_opts.notif_off_class)
	1442	+ .attr('title', VBOCore.options.tn_texts.notifs_disabled);
	1443	+
	1444	+ // register click-event listener on button to enable notifications
	1445	+ $(selector).on('click', function() {
	1446	+ VBOCore.requestNotifPerms(selector);
	1447	+ });
	1448	+
	1449	+ // add "shaking" class to make the selector more appealing
	1450	+ $(selector).addClass('shaking');
	1451	+
	1452	+ // remove the "shaking" class after some time
	1453	+ setTimeout(() => {
	1454	+ $(selector).removeClass('shaking');
	1455	+ }, 2000);
	1456	+ }
	1457	+
	1458	+ /**
	1459	+ * Tells whether the notifications are enabled, disabled, not supported.
	1460	+ */
	1461	+ static notificationsEnabled() {
	1462	+ if (!('Notification' in window)) {
	1463	+ // not supported
	1464	+ return null;
	1465	+ }
	1466	+
	1467	+ if (Notification.permission && Notification.permission === 'granted') {
	1468	+ // enabled
	1469	+ return true;
	1470	+ }
	1471	+
	1472	+ // disabled
	1473	+ return false;
	1474	+ }
	1475	+
	1476	+ /**
	1477	+ * Attempts to request the notifications permissions to the browser.
	1478	+ * For security reasons, this should run upon a user gesture (click).
	1479	+ *
	1480	+ * @param string selector optional element query selector.
	1481	+ */
	1482	+ static requestNotifPerms(selector) {
	1483	+ if (!('Notification' in window)) {
	1484	+ // browser does not support notifications
	1485	+ return false;
	1486	+ }
	1487	+
	1488	+ // run permissions request in a try-catch statement to support all browsers
	1489	+ try {
	1490	+ // handle promise-based version to request permissions
	1491	+ Notification.requestPermission().then((permission) => {
	1492	+ VBOCore.handleNotifPerms(permission, selector);
	1493	+ });
	1494	+ } catch(e) {
	1495	+ // run the callback-based version
	1496	+ Notification.requestPermission(function(permission) {
	1497	+ VBOCore.handleNotifPerms(permission, selector);
	1498	+ });
	1499	+ }
	1500	+ }
	1501	+
	1502	+ /**
	1503	+ * Handles the notifications permission response (from callback or promise resolved).
	1504	+ *
	1505	+ * @param any permission permission status string or NotificationPermission object.
	1506	+ * @param string selector optional element query selector.
	1507	+ */
	1508	+ static handleNotifPerms(permission, selector) {
	1509	+ // check the permission status from the Notification object interface
	1510	+ if ((Notification.permission && Notification.permission === 'granted') || (typeof permission === 'string' && permission === 'granted')) {
	1511	+ // permissions granted!
	1512	+ $((selector || VBOCore.options.panel_opts.notif_selector))
	1513	+ .removeClass(VBOCore.options.panel_opts.notif_off_class)
	1514	+ .addClass(VBOCore.options.panel_opts.notif_on_class)
	1515	+ .attr('title', VBOCore.options.tn_texts.notifs_enabled);
	1516	+
	1517	+ // dispatch an immediate notification to congratulate with the activation
	1518	+ VBOCore.dispatchCongratulations();
	1519	+
	1520	+ return true;
	1521	+ } else {
	1522	+ // permissions denied :(
	1523	+ $((selector || VBOCore.options.panel_opts.notif_selector))
	1524	+ .removeClass(VBOCore.options.panel_opts.notif_on_class)
	1525	+ .addClass(VBOCore.options.panel_opts.notif_off_class)
	1526	+ .attr('title', VBOCore.options.tn_texts.notifs_disabled);
	1527	+
	1528	+ // show alert message
	1529	+ console.error('Permission denied for enabling browser notifications', permission);
	1530	+ alert(VBOCore.options.tn_texts.notifs_disabled_help);
	1531	+ }
	1532	+
	1533	+ return false;
	1534	+ }
	1535	+
	1536	+ /**
	1537	+ * Dispatches an immediate notification with a congratulations text.
	1538	+ *
	1539	+ * @return void
	1540	+ */
	1541	+ static dispatchCongratulations() {
	1542	+ try {
	1543	+ let notif = new Notification(VBOCore.options.tn_texts.congrats, {
	1544	+ body: VBOCore.options.tn_texts.notifs_enabled,
	1545	+ tag: 'vbo_notification_congrats',
	1546	+ silent: false
	1547	+ });
	1548	+ } catch(error) {
	1549	+ alert(error);
	1550	+ }
	1551	+ }
	1552	+
	1553	+ /**
	1554	+ * Given a date-time string, returns a Date object representation.
	1555	+ *
	1556	+ * @param string dtime_str the date-time string in "Y-m-d H:i:s" format.
	1557	+ */
	1558	+ static getDateTimeObject(dtime_str) {
	1559	+ // instantiate a new date object
	1560	+ var date_obj = new Date();
	1561	+
	1562	+ // parse date-time string
	1563	+ let dtime_parts = dtime_str.split(' ');
	1564	+ let date_parts = dtime_parts[0].split('-');
	1565	+ if (dtime_parts.length != 2 || date_parts.length != 3) {
	1566	+ // invalid military format
	1567	+ return date_obj;
	1568	+ }
	1569	+ let time_parts = dtime_parts[1].split(':');
	1570	+
	1571	+ // set accurate date-time values
	1572	+ date_obj.setFullYear(date_parts[0]);
	1573	+ date_obj.setMonth((parseInt(date_parts[1]) - 1));
	1574	+ date_obj.setDate(parseInt(date_parts[2]));
	1575	+ date_obj.setHours(parseInt(time_parts[0]));
	1576	+ date_obj.setMinutes(parseInt(time_parts[1]));
	1577	+ date_obj.setSeconds(0);
	1578	+ date_obj.setMilliseconds(0);
	1579	+
	1580	+ // return the accurate date object
	1581	+ return date_obj;
	1582	+ }
	1583	+
	1584	+ /**
	1585	+ * Given a list of schedules, enqueues notifications to watch.
	1586	+ *
	1587	+ * @param array|object schedules list of or one notification object(s).
	1588	+ *
	1589	+ * @return bool
	1590	+ */
	1591	+ static enqueueNotifications(schedules) {
	1592	+ if (!Array.isArray(schedules) || !schedules.length) {
	1593	+ if (typeof schedules === 'object' && schedules.hasOwnProperty('dtime')) {
	1594	+ // convert the single schedule to an array
	1595	+ schedules = [schedules];
	1596	+ } else {
	1597	+ // invalid argument passed
	1598	+ return false;
	1599	+ }
	1600	+ }
	1601	+
	1602	+ for (var i in schedules) {
	1603	+ if (!schedules.hasOwnProperty(i) || typeof schedules[i] !== 'object') {
	1604	+ continue;
	1605	+ }
	1606	+ VBOCore.notifications.push(schedules[i]);
	1607	+ }
	1608	+
	1609	+ // setup the timeouts to schedule the notifications
	1610	+ return VBOCore.scheduleNotifications();
	1611	+ }
	1612	+
	1613	+ /**
	1614	+ * Schedule the trigger timings for each notification.
	1615	+ */
	1616	+ static scheduleNotifications() {
	1617	+ if (!VBOCore.notifications.length) {
	1618	+ // no notifications to be scheduled
	1619	+ return false;
	1620	+ }
	1621	+ if (VBOCore.notificationsEnabled() !== true) {
	1622	+ // notifications not enabled
	1623	+ console.info('Browser notifications disabled or unsupported.');
	1624	+ return false;
	1625	+ }
	1626	+
	1627	+ // gather current date-timing information
	1628	+ const now_date = new Date();
	1629	+ const now_time = now_date.getTime();
	1630	+
	1631	+ // parse all notifications to schedule the timers if not set
	1632	+ for (let i = 0; i < VBOCore.notifications.length; i++) {
	1633	+ let notif = VBOCore.notifications[i];
	1634	+
	1635	+ if (typeof notif !== 'object' || !notif.hasOwnProperty('dtime')) {
	1636	+ // invalid notification object, unset it
	1637	+ VBOCore.notifications.splice(i, 1);
	1638	+ continue;
	1639	+ }
	1640	+
	1641	+ // check if timer has been set
	1642	+ if (!notif.hasOwnProperty('id_timer')) {
	1643	+ // estimate trigger timing
	1644	+ let in_ms = 0;
	1645	+ // check for imminent notifications
	1646	+ if (typeof notif.dtime === 'string' && notif.dtime.indexOf('now') >= 0) {
	1647	+ // imminent ones will be delayed by one second
	1648	+ in_ms = 1000;
	1649	+ } else {
	1650	+ // check overdue date-time (notif.dtime can also be a Date object instance)
	1651	+ let nexp = VBOCore.getDateTimeObject(notif.dtime);
	1652	+ in_ms = nexp.getTime() - now_time;
	1653	+ }
	1654	+ if (in_ms > 0) {
	1655	+ // schedule notification trigger
	1656	+ let id_timer = setTimeout(() => {
	1657	+ VBOCore.dispatchNotification(notif);
	1658	+ }, in_ms);
	1659	+ // set timer on notification object
	1660	+ VBOCore.notifications[i]['id_timer'] = id_timer;
	1661	+ }
	1662	+ }
	1663	+ }
	1664	+
	1665	+ return true;
	1666	+ }
	1667	+
	1668	+ /**
	1669	+ * Deregister all scheduled notifications.
	1670	+ */
	1671	+ static unscheduleNotifications() {
	1672	+ if (!VBOCore.notifications.length) {
	1673	+ // no notifications scheduled
	1674	+ return false;
	1675	+ }
	1676	+
	1677	+ for (let i = 0; i < VBOCore.notifications.length; i++) {
	1678	+ let notif = VBOCore.notifications[i];
	1679	+
	1680	+ if (typeof notif === 'object' && notif.hasOwnProperty('id_timer')) {
	1681	+ // unset timeout for this notification
	1682	+ clearTimeout(notif['id_timer']);
	1683	+ }
	1684	+ }
	1685	+
	1686	+ // reset pool
	1687	+ VBOCore.notifications = [];
	1688	+ }
	1689	+
	1690	+ /**
	1691	+ * Update or delete a previously scheduled notification.
	1692	+ *
	1693	+ * @param object match_props map of properties to match.
	1694	+ * @param string|number newdtime the new date time to schedule (0 for deleting).
	1695	+ *
	1696	+ * @return null|bool true only if a notification matched.
	1697	+ */
	1698	+ static updateNotification(match_props, newdtime) {
	1699	+ if (!VBOCore.notifications.length) {
	1700	+ // no notifications set, terminate
	1701	+ return null;
	1702	+ }
	1703	+
	1704	+ if (typeof match_props !== 'object') {
	1705	+ // no properties to match the notification
	1706	+ return null;
	1707	+ }
	1708	+
	1709	+ // gather current date-timing information
	1710	+ const now_date = new Date();
	1711	+ const now_time = now_date.getTime();
	1712	+
	1713	+ // parse all notifications scheduled
	1714	+ for (let i = 0; i < VBOCore.notifications.length; i++) {
	1715	+ let notif = VBOCore.notifications[i];
	1716	+
	1717	+ let all_matched = true;
	1718	+ let to_matching = false;
	1719	+ for (let prop in match_props) {
	1720	+ if (!match_props.hasOwnProperty(prop)) {
	1721	+ continue;
	1722	+ }
	1723	+ to_matching = true;
	1724	+ if (!notif.hasOwnProperty(prop) || notif[prop] != match_props[prop]) {
	1725	+ all_matched = false;
	1726	+ break;
	1727	+ }
	1728	+ }
	1729	+
	1730	+ if (all_matched && to_matching) {
	1731	+ // notification object found
	1732	+ if (notif.hasOwnProperty('id_timer')) {
	1733	+ // unset previous timeout for this notification
	1734	+ clearTimeout(notif['id_timer']);
	1735	+ }
	1736	+ // update or delete scheduled notification
	1737	+ if (newdtime === 0) {
	1738	+ // delete notification from queue
	1739	+ VBOCore.notifications.splice(i, 1);
	1740	+ } else {
	1741	+ // update timing scheduler
	1742	+ let in_ms = 0;
	1743	+ // check for imminent notifications
	1744	+ if (typeof newdtime === 'string' && newdtime.indexOf('now') >= 0) {
	1745	+ // imminent ones will be delayed by one second
	1746	+ in_ms = 1000;
	1747	+ } else {
	1748	+ // check overdue date-time (newdtime can also be a Date object instance)
	1749	+ let nexp = VBOCore.getDateTimeObject(newdtime);
	1750	+ in_ms = nexp.getTime() - now_time;
	1751	+ }
	1752	+ if (in_ms > 0) {
	1753	+ // schedule notification trigger
	1754	+ let id_timer = setTimeout(() => {
	1755	+ VBOCore.dispatchNotification(notif);
	1756	+ }, in_ms);
	1757	+ // set timer on notification object
	1758	+ VBOCore.notifications[i]['id_timer'] = id_timer;
	1759	+ }
	1760	+ // update date-time value on notification object
	1761	+ VBOCore.notifications[i]['dtime'] = newdtime;
	1762	+ }
	1763	+
	1764	+ // terminate parsing and return true
	1765	+ return true;
	1766	+ }
	1767	+ }
	1768	+
	1769	+ // notification object not found
	1770	+ return false;
	1771	+ }
	1772	+
	1773	+ /**
	1774	+ * Dispatch the notification object.
	1775	+ * Expected notification properties:
	1776	+ *
	1777	+ * {
	1778	+ * id: number
	1779	+ * type: string
	1780	+ * dtime: string|Date
	1781	+ * build_url: string|null
	1782	+ * }
	1783	+ *
	1784	+ * @param object notif the notification object.
	1785	+ */
	1786	+ static dispatchNotification(notif) {
	1787	+ if (typeof notif !== 'object') {
	1788	+ return false;
	1789	+ }
	1790	+
	1791	+ // subscribe to building notification data
	1792	+ VBOCore.buildNotificationData(notif).then((data) => {
	1793	+ // dispatch the notification
	1794	+
	1795	+ // check if the click event should be registered
	1796	+ let func_nodes;
	1797	+ if (data.onclick && typeof data.onclick === 'string') {
	1798	+ let callback_parts = data.onclick.split('.');
	1799	+ while (callback_parts.length) {
	1800	+ // compose window static method string to avoid using eval()
	1801	+ let tmp = callback_parts.shift();
	1802	+ if (!func_nodes) {
	1803	+ func_nodes = window[tmp];
	1804	+ } else {
	1805	+ func_nodes = func_nodes[tmp];
	1806	+ }
	1807	+ }
	1808	+ }
	1809	+
	1810	+ // prepare properties to delete the notification from queue
	1811	+ let match_props = {};
	1812	+ for (let prop in notif) {
	1813	+ if (!notif.hasOwnProperty(prop) || prop == 'id_timer') {
	1814	+ continue;
	1815	+ }
	1816	+ match_props[prop] = notif[prop];
	1817	+ }
	1818	+
	1819	+ // check browser Notifications API
	1820	+ if (VBOCore.notificationsEnabled() !== true) {
	1821	+ // notifications not enabled, fallback to toast message
	1822	+ let toast_notif_data = {
	1823	+ title: data.title,
	1824	+ body: data.message,
	1825	+ icon: data.icon,
	1826	+ delay: {
	1827	+ min: 6000,
	1828	+ max: 20000,
	1829	+ tolerance: 4000,
	1830	+ },
	1831	+ action: () => {
	1832	+ VBOToast.dispose(true);
	1833	+ },
	1834	+ sound: VBOCore.options.notif_audio_url
	1835	+ };
	1836	+ if (func_nodes) {
	1837	+ toast_notif_data.action = function() {
	1838	+ func_nodes(data);
	1839	+ VBOToast.dispose(true);
	1840	+ };
	1841	+ } else if (typeof data.onclick === 'function') {
	1842	+ toast_notif_data.action = function() {
	1843	+ data.onclick.call(data);
	1844	+ VBOToast.dispose(true);
	1845	+ };
	1846	+ }
	1847	+ VBOToast.enqueue(new VBOToastMessage(toast_notif_data));
	1848	+
	1849	+ // delete dispatched notification from queue
	1850	+ VBOCore.updateNotification(match_props, 0);
	1851	+
	1852	+ return;
	1853	+ }
	1854	+
	1855	+ // use the browser's native Notifications API
	1856	+ let browser_notif = new Notification(data.title, {
	1857	+ body: data.message,
	1858	+ icon: data.icon,
	1859	+ tag: 'vbo_notification',
	1860	+ silent: false
	1861	+ });
	1862	+
	1863	+ // check if support for Web App badge is available
	1864	+ if (typeof navigator.setAppBadge !== 'undefined') {
	1865	+ navigator.setAppBadge(1);
	1866	+ }
	1867	+
	1868	+ browser_notif.addEventListener('click', (e) => {
	1869	+ // check if support for Web App badge is available
	1870	+ if (typeof navigator.setAppBadge !== 'undefined') {
	1871	+ navigator.clearAppBadge();
	1872	+ }
	1873	+ // close the notification
	1874	+ e.target.close();
	1875	+ });
	1876	+
	1877	+ if (func_nodes) {
	1878	+ // register notification click event
	1879	+ browser_notif.addEventListener('click', () => {
	1880	+ func_nodes(data);
	1881	+ });
	1882	+ } else if (typeof data.onclick === 'function') {
	1883	+ browser_notif.addEventListener('click', () => {
	1884	+ data.onclick.call(data);
	1885	+ });
	1886	+ }
	1887	+
	1888	+ // delete dispatched notification from queue
	1889	+ VBOCore.updateNotification(match_props, 0);
	1890	+
	1891	+ }).catch((error) => {
	1892	+ console.error(error);
	1893	+ });
	1894	+ }
	1895	+
	1896	+ /**
	1897	+ * Asynchronous build of the notification data object for dispatch.
	1898	+ * Minimum expected notification display data properties:
	1899	+ *
	1900	+ * {
	1901	+ * title: string
	1902	+ * message: string
	1903	+ * icon: string
	1904	+ * onclick: function
	1905	+ * }
	1906	+ *
	1907	+ * @param object notif the scheduled notification object.
	1908	+ *
	1909	+ * @return Promise
	1910	+ */
	1911	+ static buildNotificationData(notif) {
	1912	+ return new Promise((resolve, reject) => {
	1913	+ // notification object validation
	1914	+ if (typeof notif !== 'object') {
	1915	+ reject('Invalid notification object');
	1916	+ return;
	1917	+ }
	1918	+
	1919	+ if (!notif.hasOwnProperty('build_url') || !notif.build_url) {
	1920	+ // building callback not necessary
	1921	+ if (!notif.title && !notif.message) {
	1922	+ reject('Unexpected notification object');
	1923	+ return;
	1924	+ }
	1925	+ // we expect the notification to be built already
	1926	+ resolve(notif);
	1927	+ return;
	1928	+ }
	1929	+
	1930	+ // build the notification data
	1931	+ VBOCore.doAjax(
	1932	+ notif.build_url,
	1933	+ {
	1934	+ payload: JSON.stringify(notif)
	1935	+ },
	1936	+ (response) => {
	1937	+ // parse response
	1938	+ try {
	1939	+ var obj_res = typeof response === 'string' ? JSON.parse(response) : response;
	1940	+ if (obj_res.hasOwnProperty('title')) {
	1941	+ resolve(obj_res);
	1942	+ } else {
	1943	+ reject('Unexpected JSON response');
	1944	+ }
	1945	+ } catch(err) {
	1946	+ reject('could not parse JSON response');
	1947	+ }
	1948	+ },
	1949	+ (error) => {
	1950	+ reject(error.responseText);
	1951	+ }
	1952	+ );
	1953	+ });
	1954	+ }
	1955	+
	1956	+ /**
	1957	+ * Handle a navigation towards a given URL.
	1958	+ * Common handler for browser notifications click.
	1959	+ *
	1960	+ * @param object data notification display data payload.
	1961	+ */
	1962	+ static handleGoto(data) {
	1963	+ if (typeof data !== 'object' || !data.hasOwnProperty('gotourl') || !data.gotourl) {
	1964	+ console.error('Could not handle the goto operation', data);
	1965	+ return;
	1966	+ }
	1967	+
	1968	+ if (typeof data.openWindow !== 'undefined' || typeof document === 'undefined') {
	1969	+ // open a new window
	1970	+ window.open(data.gotourl);
	1971	+ return;
	1972	+ }
	1973	+
	1974	+ // redirect
	1975	+ document.location.href = data.gotourl;
	1976	+ }
	1977	+
	1978	+ /**
	1979	+ * Opens a new window with the URI to render the Push notification data.
	1980	+ *
	1981	+ * @param object options admin widget rendering options to bind.
	1982	+ *
	1983	+ * @return void
	1984	+ */
	1985	+ static openAdminPushURI(options) {
	1986	+ if (typeof options !== 'object' || !options) {
	1987	+ throw new Error('Unable to build Admin Push URI');
	1988	+ }
	1989	+
	1990	+ let vbo_admin_push_uri = VBOCore.options.root_uri;
	1991	+
	1992	+ if (VBOCore.options.cms === 'wordpress') {
	1993	+ vbo_admin_push_uri += 'wp-admin/admin.php?page=vikbooking';
	1994	+ } else {
	1995	+ vbo_admin_push_uri += 'administrator/index.php?option=com_vikbooking';
	1996	+ }
	1997	+
	1998	+ // build Push notification payload for rendering
	1999	+ let push_data = {
	2000	+ type: options.type || '',
	2001	+ title: options.title || '',
	2002	+ message: options.message || '',
	2003	+ content: options,
	2004	+ };
	2005	+
	2006	+ // open page in a new window
	2007	+ window.open(vbo_admin_push_uri + '&push_notification=' + btoa(JSON.stringify(push_data)), '_blank');
	2008	+ }
	2009	+
	2010	+ /**
	2011	+ * Handle the display of a notification through a widget.
	2012	+ * Common handler for browser notifications displayed through
	2013	+ * a widget modal rendering.
	2014	+ *
	2015	+ * @param object data notification display data payload.
	2016	+ * @param object options optional extra options for the admin widget.
	2017	+ * @param boolean is_push whether we are coming from a Push notification.
	2018	+ *
	2019	+ * @return void
	2020	+ */
	2021	+ static handleDisplayWidgetNotification(data, options, is_push) {
	2022	+ try {
	2023	+ // validate handler
	2024	+ if (!VBOCore.options.is_vbo && !VBOCore.options.is_vcm) {
	2025	+ throw new Error('Unable to handle the notification display from the current page');
	2026	+ }
	2027	+
	2028	+ // validate payload
	2029	+ if (typeof data !== 'object' || !data.hasOwnProperty('widget_id') || !data['widget_id']) {
	2030	+ throw new Error('Invalid widget payload');
	2031	+ }
	2032	+
	2033	+ // parse handler
	2034	+ if (VBOCore.options.is_vcm || (is_push && !VBOCore.options.is_vbo)) {
	2035	+ // the operation is handled by VCM (or by an external admin resource, if it's a Push notification)
	2036	+ VBOCore.loadAdminWidgetAssets(data).then((assets) => {
	2037	+ // append assets to DOM
	2038	+ assets.forEach((asset) => {
	2039	+ if (!$('link#' + asset['id']).length) {
	2040	+ $('head').append('<link rel="stylesheet" id="' + asset['id'] + '" href="' + asset['href'] + '" media="all" />');
	2041	+ }
	2042	+ });
	2043	+ // widget modal rendering handled by VCM (or an external admin resource)
	2044	+ let hide_panel = VBOCore.options.is_vcm && $('.' + VBOCore.options.panel_opts.open_class).length ? true : false;
	2045	+ let modal_data = VBOCore.renderModalWidget(data['widget_id'], data, options, hide_panel);
	2046	+ if (modal_data.hasOwnProperty('dismissed_event') && (modal_data['suffix'] || '').indexOf('inner') < 0) {
	2047	+ // register event to unload all assets (only if not from an inner modal)
	2048	+ document.addEventListener(modal_data['dismissed_event'], () => {
	2049	+ assets.forEach((asset) => {
	2050	+ if ($('link#' + asset['id']).length) {
	2051	+ $('link#' + asset['id']).remove();
	2052	+ }
	2053	+ });
	2054	+ });
	2055	+ }
	2056	+ }).catch((error) => {
	2057	+ throw new Error(error);
	2058	+ });
	2059	+ } else {
	2060	+ // widget modal rendering handled by Vik Booking
	2061	+ VBOCore.renderModalWidget(data['widget_id'], data, options, false);
	2062	+ }
	2063	+ } catch(e) {
	2064	+ if (is_push && options.type) {
	2065	+ // fallback to opening a new window to render the clicked Push notification
	2066	+ VBOCore.openAdminPushURI(options);
	2067	+ } else {
	2068	+ // fallback to a regular link opening, if set
	2069	+ VBOCore.handleGoto(data);
	2070	+ }
	2071	+ }
	2072	+ }
	2073	+
	2074	+ /**
	2075	+ * Asynchronous loading of CSS assets required to render
	2076	+ * an admin widget outside Vik Booking.
	2077	+ *
	2078	+ * @param object data the optional widget payload data.
	2079	+ *
	2080	+ * @return Promise
	2081	+ */
	2082	+ static loadAdminWidgetAssets(data) {
	2083	+ return new Promise((resolve, reject) => {
	2084	+ // the remote assets URI must be set
	2085	+ if (!VBOCore.options.assets_ajax_uri) {
	2086	+ reject('Missing remote assets URI');
	2087	+ return;
	2088	+ }
	2089	+
	2090	+ if (typeof data !== 'object') {
	2091	+ data = {};
	2092	+ }
	2093	+
	2094	+ // make the request
	2095	+ VBOCore.doAjax(
	2096	+ VBOCore.options.assets_ajax_uri,
	2097	+ data,
	2098	+ (response) => {
	2099	+ // parse response
	2100	+ try {
	2101	+ var obj_res = typeof response === 'string' ? JSON.parse(response) : response;
	2102	+ if (!Array.isArray(obj_res)) {
	2103	+ reject('Unexpected JSON response');
	2104	+ }
	2105	+ resolve(obj_res);
	2106	+ } catch(err) {
	2107	+ reject('could not parse JSON response');
	2108	+ }
	2109	+ },
	2110	+ (error) => {
	2111	+ reject(error.responseText);
	2112	+ }
	2113	+ );
	2114	+ });
	2115	+ }
	2116	+
	2117	+ /**
	2118	+ * Register the latest data to watch for the preloaded admin widgets.
	2119	+ *
	2120	+ * @param object watch_data
	2121	+ */
	2122	+ static registerWatchData(watch_data) {
	2123	+ if (typeof watch_data !== 'object' || watch_data == null) {
	2124	+ VBOCore.widgets_watch_data = null;
	2125	+ return false;
	2126	+ }
	2127	+
	2128	+ // set watch-data map
	2129	+ VBOCore.widgets_watch_data = watch_data;
	2130	+
	2131	+ // schedule watching interval
	2132	+ if (VBOCore.watch_data_interval == null) {
	2133	+ VBOCore.watch_data_interval = window.setInterval(VBOCore.watchWidgetsData, 60000);
	2134	+ }
	2135	+
	2136	+ // set up broadcast channels to connect all browsing contexts
	2137	+ if (typeof BroadcastChannel !== 'undefined') {
	2138	+ // set up watch-data broadcast channel
	2139	+ if (!VBOCore.broadcast_watch_data) {
	2140	+ // start broadcast channel
	2141	+ VBOCore.broadcast_watch_data = new BroadcastChannel('vikbooking_watch_data');
	2142	+
	2143	+ // register to the "on broadcast message received" event
	2144	+ VBOCore.broadcast_watch_data.onmessage = (event) => {
	2145	+ if (event && event.data) {
	2146	+ // update watch data map for next schedule to avoid dispatching duplicate notifications
	2147	+ VBOCore.widgets_watch_data = event.data;
	2148	+ }
	2149	+ };
	2150	+ }
	2151	+
	2152	+ // set up push-data broadcast channel
	2153	+ if (!VBOCore.broadcast_push_data) {
	2154	+ // start broadcast channel
	2155	+ VBOCore.broadcast_push_data = new BroadcastChannel('vikbooking_push_data');
	2156	+
	2157	+ // register to the "on broadcast message received" event
	2158	+ VBOCore.broadcast_push_data.onmessage = (event) => {
	2159	+ if (event && event.data) {
	2160	+ // update pushed data map for the next watching event
	2161	+ VBOCore.widgets_pushed_data.push(event.data);
	2162	+ }
	2163	+ };
	2164	+ }
	2165	+
	2166	+ // set up watch-events broadcast channel
	2167	+ if (!VBOCore.broadcast_watch_events) {
	2168	+ // start broadcast channel
	2169	+ VBOCore.broadcast_watch_events = new BroadcastChannel('vikbooking_watch_events');
	2170	+
	2171	+ // register to the "on broadcast message received" event
	2172	+ VBOCore.broadcast_watch_events.onmessage = (event) => {
	2173	+ if (event && event.data && typeof event.data === 'object') {
	2174	+ // scan and dispatch the events data received
	2175	+ let events_data = event.data;
	2176	+ for (let ev_name in events_data) {
	2177	+ if (!events_data.hasOwnProperty(ev_name)) {
	2178	+ continue;
	2179	+ }
	2180	+ // emit the event
	2181	+ VBOCore.emitEvent(ev_name, events_data[ev_name]);
	2182	+ }
	2183	+ }
	2184	+ };
	2185	+ }
	2186	+ }
	2187	+ }
	2188	+
	2189	+ /**
	2190	+ * Periodic widgets data watching for new events.
	2191	+ */
	2192	+ static watchWidgetsData() {
	2193	+ if (typeof VBOCore.widgets_watch_data !== 'object' || VBOCore.widgets_watch_data == null) {
	2194	+ return;
	2195	+ }
	2196	+
	2197	+ // call on new events
	2198	+ VBOCore.doAjax(
	2199	+ VBOCore.options.watchdata_ajax_uri,
	2200	+ {
	2201	+ watch_data: JSON.stringify(VBOCore.widgets_watch_data),
	2202	+ pushed_data: JSON.stringify(VBOCore.widgets_pushed_data),
	2203	+ },
	2204	+ (response) => {
	2205	+ try {
	2206	+ var obj_res = typeof response === 'string' ? JSON.parse(response) : response;
	2207	+ if (obj_res.hasOwnProperty('watch_data')) {
	2208	+ // update watch data map for next schedule
	2209	+ VBOCore.widgets_watch_data = obj_res['watch_data'];
	2210	+
	2211	+ // check for notifications
	2212	+ if (obj_res.hasOwnProperty('notifications') && Array.isArray(obj_res['notifications'])) {
	2213	+ // dispatch notifications
	2214	+ for (var i = 0; i < obj_res['notifications'].length; i++) {
	2215	+ VBOCore.dispatchNotification(obj_res['notifications'][i]);
	2216	+ }
	2217	+
	2218	+ // post message onto broadcast channel for any other browsing context
	2219	+ if (VBOCore.broadcast_watch_data && obj_res['notifications'].length) {
	2220	+ // this will avoid dispatching duplicate notifications
	2221	+ VBOCore.broadcast_watch_data.postMessage(VBOCore.widgets_watch_data);
	2222	+ }
	2223	+ }
	2224	+
	2225	+ // check for notification events to dispatch
	2226	+ if (obj_res.hasOwnProperty('events') && Array.isArray(obj_res['events'])) {
	2227	+ // parse and dispatch all the events
	2228	+ obj_res['events'].forEach((events_data) => {
	2229	+ if (typeof events_data !== 'object') {
	2230	+ return;
	2231	+ }
	2232	+
	2233	+ // parse all the events for this widget watched data
	2234	+ for (let ev_name in events_data) {
	2235	+ if (!events_data.hasOwnProperty(ev_name)) {
	2236	+ continue;
	2237	+ }
	2238	+ // emit the event
	2239	+ VBOCore.emitEvent(ev_name, events_data[ev_name]);
	2240	+ }
	2241	+
	2242	+ // post message onto broadcast channel for any other browsing context
	2243	+ if (VBOCore.broadcast_watch_events) {
	2244	+ // this will trigger the events on any other browsing context
	2245	+ VBOCore.broadcast_watch_events.postMessage(events_data);
	2246	+ }
	2247	+ });
	2248	+ }
	2249	+ } else {
	2250	+ console.error('Unexpected or invalid JSON response', response);
	2251	+ }
	2252	+ } catch(err) {
	2253	+ console.error('could not parse JSON response', err, response);
	2254	+ }
	2255	+ },
	2256	+ (error) => {
	2257	+ console.error(error.responseText);
	2258	+ }
	2259	+ );
	2260	+ }
	2261	+
	2262	+ /**
	2263	+ * Widget modal rendering.
	2264	+ *
	2265	+ * @param string widget_id the widget identifier to render.
	2266	+ * @param any data the optional multitask data to inject.
	2267	+ * @param object options optional list of extra options to render the widget with Multitask data.
	2268	+ * @param bool hide_panel if false, the multitask panel elements will remain unchanged.
	2269	+ *
	2270	+ * @return object the multitask data injected object merged with modal options.
	2271	+ */
	2272	+ static renderModalWidget(widget_id, data, options, hide_panel) {
	2273	+ /**
	2274	+ * Adjust arguments for BC with previous ordering between options
	2275	+ * and hide_panel, which used to be inverted. Useful also to shorten
	2276	+ * the way the method can be invoked in case no options are needed.
	2277	+ */
	2278	+ if (typeof options === 'boolean') {
	2279	+ // switch argument values
	2280	+ hide_panel = options;
	2281	+ options = null;
	2282	+ }
	2283	+
	2284	+ if (typeof data !== 'object' || data == null) {
	2285	+ // always treat data as an object
	2286	+ data = {};
	2287	+ }
	2288	+
	2289	+ if (typeof options !== 'object' || options == null) {
	2290	+ // always treat options as an object
	2291	+ options = data._options || {};
	2292	+ }
	2293	+
	2294	+ // build the default widget payload
	2295	+ let modal_js_id = Math.floor(Math.random() * 100000);
	2296	+ let modal_title = options._push && options.title ? options.title : VBOCore.options.tn_texts.admin_widget;
	2297	+ let widget_data = {
	2298	+ _modalRendering: 1,
	2299	+ _modalJsId: modal_js_id,
	2300	+ _modalTitle: modal_title,
	2301	+ _options: options,
	2302	+ };
	2303	+
	2304	+ // merge default payload options with given options
	2305	+ data = Object.assign(widget_data, data);
	2306	+
	2307	+ // define unique modal event names to avoid conflicts
	2308	+ let dismiss_event = 'vbo-dismiss-widget-modal' + modal_js_id;
	2309	+ let loading_event = 'vbo-loading-widget-modal' + modal_js_id;
	2310	+ let resize_event = 'vbo-resize-widget-modal' + modal_js_id;
	2311	+
	2312	+ // define the modal options
	2313	+ let modal_options = {
	2314	+ suffix: 'widget_modal',
	2315	+ extra_class: 'vbo-modal-widget vbo-modal-rounded vbo-modal-tall vbo-modal-nofooter',
	2316	+ title: data._modalTitle,
	2317	+ body_prepend: true,
	2318	+ lock_scroll: true,
	2319	+ draggable: true,
	2320	+ enlargeable: true,
	2321	+ minimizeable: VBOCore.options.is_vbo,
	2322	+ resize_event: resize_event,
	2323	+ dismiss_event: dismiss_event,
	2324	+ loading_event: loading_event,
	2325	+ loading_body: VBOCore.options.default_loading_body,
	2326	+ dismissed_event: VBOCore.options.widget_modal_dismissed + modal_js_id,
	2327	+ event_data: widget_data,
	2328	+ };
	2329	+
	2330	+ // check if options should rewrite some modal-options
	2331	+ if (options.modal_options) {
	2332	+ modal_options = Object.assign(modal_options, options.modal_options);
	2333	+ }
	2334	+
	2335	+ // display modal
	2336	+ let widget_modal = VBOCore.displayModal(modal_options);
	2337	+
	2338	+ if (hide_panel !== false) {
	2339	+ // blur search widget input, hide multitask panel
	2340	+ $(VBOCore.options.panel_opts.search_selector).trigger('blur');
	2341	+ VBOCore.emitEvent(VBOCore.multitask_shortcut_event);
	2342	+ }
	2343	+
	2344	+ // start loading
	2345	+ VBOCore.emitEvent(loading_event);
	2346	+
	2347	+ // render admin widget
	2348	+ VBOCore.renderAdminWidget(widget_id, data).then((content) => {
	2349	+ // stop loading and append widget content to modal
	2350	+ VBOCore.emitEvent(loading_event);
	2351	+ widget_modal.append(content);
	2352	+
	2353	+ // register an admin menu action for the rendered widget
	2354	+ VBOCore.fetchWidgetDetails(widget_id).then((details) => {
	2355	+ // update modal title, if default title is present
	2356	+ if (modal_options.title == VBOCore.options.tn_texts.admin_widget) {
	2357	+ widget_modal
	2358	+ .closest('.vbo-modal-overlay-content')
	2359	+ .find('.vbo-modal-overlay-content-head-title')
	2360	+ .text(data._modalTitle + ' - ' + details.name);
	2361	+ }
	2362	+
	2363	+ // check if this widget returned a particular modal setup
	2364	+ if (details?.modal) {
	2365	+ if (details.modal?.add_class) {
	2366	+ // add custom modal class
	2367	+ widget_modal
	2368	+ .closest('.vbo-modal-overlay-content')
	2369	+ .addClass(details.modal.add_class);
	2370	+
	2371	+ // fire the "resize" event with a delay to support the CSS transition
	2372	+ setTimeout(() => {
	2373	+ VBOCore.emitEvent(resize_event, {
	2374	+ content: widget_modal,
	2375	+ });
	2376	+ }, 400);
	2377	+ }
	2378	+ }
	2379	+
	2380	+ // set data for widget details
	2381	+ widget_modal.data('details', JSON.stringify(details));
	2382	+
	2383	+ // register admin menu action
	2384	+ try {
	2385	+ // work on Local Storage to register the widget data
	2386	+ VBOCore.registerAdminMenuAction({
	2387	+ name: details.name,
	2388	+ href: 'JavaScript: void(0);',
	2389	+ widget: widget_id,
	2390	+ icon: details.icon,
	2391	+ style: details.style,
	2392	+ }, 'widgets');
	2393	+ } catch(e) {
	2394	+ console.error(e);
	2395	+ }
	2396	+ }).catch((error) => {
	2397	+ console.error(error);
	2398	+ });
	2399	+ }).catch((error) => {
	2400	+ // dismiss modal and display error
	2401	+ VBOCore.emitEvent(dismiss_event);
	2402	+ alert(error);
	2403	+ });
	2404	+
	2405	+ return Object.assign(data, modal_options);
	2406	+ }
	2407	+
	2408	+ /**
	2409	+ * Renders an admin widget.
	2410	+ *
	2411	+ * @param string widget_id the widget identifier string to add.
	2412	+ * @param any data the optional multitask data to inject.
	2413	+ *
	2414	+ * @return Promise
	2415	+ */
	2416	+ static renderAdminWidget(widget_id, data) {
	2417	+ return new Promise((resolve, reject) => {
	2418	+ if (!VBOCore.options.widget_ajax_uri) {
	2419	+ reject('Could not load admin widget');
	2420	+ return;
	2421	+ }
	2422	+
	2423	+ var call_method = 'render';
	2424	+ VBOCore.doAjax(
	2425	+ VBOCore.options.widget_ajax_uri,
	2426	+ {
	2427	+ widget_id: widget_id,
	2428	+ call: call_method,
	2429	+ vbo_page: VBOCore.options.current_page,
	2430	+ vbo_uri: VBOCore.options.current_page_uri,
	2431	+ multitask: 1,
	2432	+ multitask_data: data,
	2433	+ },
	2434	+ (response) => {
	2435	+ // parse response
	2436	+ try {
	2437	+ var obj_res = typeof response === 'string' ? JSON.parse(response) : response;
	2438	+ if (!obj_res.hasOwnProperty(call_method)) {
	2439	+ reject('Unexpected JSON response');
	2440	+ return;
	2441	+ }
	2442	+ resolve(obj_res[call_method]);
	2443	+ } catch(err) {
	2444	+ reject('could not parse JSON response');
	2445	+ }
	2446	+ },
	2447	+ (error) => {
	2448	+ reject(error.responseText);
	2449	+ }
	2450	+ );
	2451	+ });
	2452	+ }
	2453	+
	2454	+ /**
	2455	+ * Renders an admin widget "inline", by loading the necessary assets.
	2456	+ * To be called outside VikBooking for displaying an admin widget.
	2457	+ *
	2458	+ * @param string widget_id the widget identifier string to add.
	2459	+ * @param any data the optional multitask data to inject.
	2460	+ *
	2461	+ * @return Promise
	2462	+ */
	2463	+ static handleDisplayInlineWidget(widget_id, data) {
	2464	+ return new Promise((resolve, reject) => {
	2465	+ if (VBOCore.options.is_vbo) {
	2466	+ reject('Unable to display the inline widget within VikBooking.');
	2467	+ return;
	2468	+ }
	2469	+
	2470	+ VBOCore.loadAdminWidgetAssets(data).then((assets) => {
	2471	+ // append assets to DOM
	2472	+ assets.forEach((asset) => {
	2473	+ if (!$('link#' + asset['id']).length) {
	2474	+ $('head').append('<link rel="stylesheet" id="' + asset['id'] + '" href="' + asset['href'] + '" media="all" />');
	2475	+ }
	2476	+ });
	2477	+ VBOCore.renderAdminWidget(widget_id, data).then((content) => {
	2478	+ resolve(content);
	2479	+ }).catch((error) => {
	2480	+ reject(error);
	2481	+ });
	2482	+ }).catch((error) => {
	2483	+ reject(error);
	2484	+ });
	2485	+ });
	2486	+ }
	2487	+
	2488	+ /**
	2489	+ * Fetches the details for a specific widget.
	2490	+ *
	2491	+ * @param string widget_id the widget identifier string to fetch.
	2492	+ *
	2493	+ * @return Promise
	2494	+ *
	2495	+ * @since 1.6.7
	2496	+ */
	2497	+ static fetchWidgetDetails(widget_id) {
	2498	+ return new Promise((resolve, reject) => {
	2499	+ if (!VBOCore.options.widget_ajax_uri) {
	2500	+ reject('Could not load admin widget');
	2501	+ return;
	2502	+ }
	2503	+
	2504	+ var call_method = 'getWidgetDetails';
	2505	+ VBOCore.doAjax(
	2506	+ VBOCore.options.widget_ajax_uri,
	2507	+ {
	2508	+ widget_id: widget_id,
	2509	+ call: call_method,
	2510	+ return: 1,
	2511	+ },
	2512	+ (response) => {
	2513	+ // parse response
	2514	+ try {
	2515	+ var obj_res = typeof response === 'string' ? JSON.parse(response) : response;
	2516	+ if (!obj_res.hasOwnProperty(call_method)) {
	2517	+ reject('Unexpected JSON response');
	2518	+ return;
	2519	+ }
	2520	+ resolve(obj_res[call_method]);
	2521	+ } catch(err) {
	2522	+ reject('could not parse JSON response');
	2523	+ }
	2524	+ },
	2525	+ (error) => {
	2526	+ reject(error.responseText);
	2527	+ }
	2528	+ );
	2529	+ });
	2530	+ }
	2531	+
	2532	+ /**
	2533	+ * Helper method used to copy the text of an
	2534	+ * input element within the clipboard.
	2535	+ *
	2536	+ * Clipboard copy will take effect only in case the
	2537	+ * function is handled by a DOM event explicitly
	2538	+ * triggered by the user, such as a "click".
	2539	+ *
	2540	+ * @param any input The input containing the text to copy.
	2541	+ *
	2542	+ * @return Promise
	2543	+ */
	2544	+ static copyToClipboard(input) {
	2545	+ // register and return promise
	2546	+ return new Promise((resolve, reject) => {
	2547	+ // define a fallback function
	2548	+ var fallback = function(input) {
	2549	+ // focus the input
	2550	+ input.focus();
	2551	+ // select the text inside the input
	2552	+ input.select();
	2553	+
	2554	+ try {
	2555	+ // try to copy with shell command
	2556	+ var copy = document.execCommand('copy');
	2557	+
	2558	+ if (copy) {
	2559	+ // copied successfully
	2560	+ resolve(copy);
	2561	+ } else {
	2562	+ // unable to copy
	2563	+ reject(copy);
	2564	+ }
	2565	+ } catch (error) {
	2566	+ // unable to exec the command
	2567	+ reject(error);
	2568	+ }
	2569	+ };
	2570	+
	2571	+ // look for navigator clipboard
	2572	+ if (!navigator || !navigator.clipboard) {
	2573	+ // navigator clipboard not supported, use fallback
	2574	+ fallback(input);
	2575	+ return;
	2576	+ }
	2577	+
	2578	+ // try to copy within the clipboard by using the navigator
	2579	+ navigator.clipboard.writeText((input.val ? input.val() : input.value)).then(() => {
	2580	+ // copied successfully
	2581	+ resolve(true);
	2582	+ }).catch((error) => {
	2583	+ // revert to the fallback
	2584	+ fallback(input);
	2585	+ });
	2586	+ });
	2587	+ }
	2588	+
	2589	+ /**
	2590	+ * Helper method used to display a modal window dinamycally.
	2591	+ *
	2592	+ * @param object options The options to render the modal.
	2593	+ * @param object bindDetails Optional data to bind to the modal content.
	2594	+ *
	2595	+ * @return object The modal content element wrapper.
	2596	+ */
	2597	+ static displayModal(options, bindDetails) {
	2598	+ var def_options = {
	2599	+ suffix: (Math.floor(Math.random() * 100000)) + '',
	2600	+ extra_class: null,
	2601	+ header: true,
	2602	+ title: '',
	2603	+ body: '',
	2604	+ body_prepend: false,
	2605	+ lock_scroll: false,
	2606	+ draggable: false,
	2607	+ enlargeable: false,
	2608	+ minimizeable: false,
	2609	+ escape_dismiss: true,
	2610	+ footer_left: null,
	2611	+ footer_right: null,
	2612	+ footer_center: null,
	2613	+ resize_event: null,
	2614	+ dismiss_event: null,
	2615	+ dismissed_event: 'vbo-modal-dismissed',
	2616	+ onDismiss: null,
	2617	+ onMinimize: null,
	2618	+ onRestore: null,
	2619	+ loading_event: null,
	2620	+ loading_body: VBOCore.options.default_loading_body,
	2621	+ progress_event: null,
	2622	+ event_data: null,
	2623	+ };
	2624	+
	2625	+ if (options.event_data && typeof options.event_data === 'object') {
	2626	+ // get rid of possible cyclic object references
	2627	+ options.event_data = Object.assign({}, options.event_data);
	2628	+ }
	2629	+
	2630	+ // merge default options with given options
	2631	+ options = Object.assign(def_options, options);
	2632	+
	2633	+ // create the modal destroy function
	2634	+ const modal_destroy_fn = (e) => {
	2635	+ // invoke callback for onDismiss
	2636	+ if (typeof options.onDismiss === 'function') {
	2637	+ options.onDismiss.call(custom_modal, e);
	2638	+ }
	2639	+
	2640	+ // check if modal did register to the loading event
	2641	+ if (options.loading_event) {
	2642	+ // we can now un-register from the loading event until a new modal is displayed and will register to it again
	2643	+ document.removeEventListener(options.loading_event, modal_handle_loading_event_fn);
	2644	+ if (options.progress_event) {
	2645	+ // we can now un-register from the progress event
	2646	+ document.removeEventListener(options.progress_event, modal_handle_progress_event_fn);
	2647	+ }
	2648	+ }
	2649	+
	2650	+ // check if we should fire the given modal dismissed event
	2651	+ if (options.dismissed_event) {
	2652	+ VBOCore.emitEvent(options.dismissed_event, options.event_data);
	2653	+ }
	2654	+
	2655	+ // check if body scroll lock should be removed
	2656	+ if (options.lock_scroll) {
	2657	+ $('body').removeClass('vbo-modal-lock-scroll');
	2658	+ }
	2659	+
	2660	+ // remove modal from DOM
	2661	+ custom_modal.remove();
	2662	+ };
	2663	+
	2664	+ // create the modal dismiss function
	2665	+ const modal_dismiss_fn = (e) => {
	2666	+ custom_modal.fadeOut(400, () => {
	2667	+ // destroy the modal
	2668	+ modal_destroy_fn.call(custom_modal, e);
	2669	+ });
	2670	+ };
	2671	+
	2672	+ // create the modal loading event handler function
	2673	+ const modal_handle_loading_event_fn = (e) => {
	2674	+ // toggle modal loading
	2675	+ if ($('.vbo-modal-overlay-content-backdrop').length) {
	2676	+ // hide loading
	2677	+ $('.vbo-modal-overlay-content-backdrop').remove();
	2678	+
	2679	+ // do not proceed
	2680	+ return;
	2681	+ }
	2682	+
	2683	+ // show loading
	2684	+ var modal_loading = $('<div></div>').addClass('vbo-modal-overlay-content-backdrop');
	2685	+ var modal_loading_body = $('<div></div>').addClass('vbo-modal-overlay-content-backdrop-body');
	2686	+ if (options.loading_body) {
	2687	+ modal_loading_body.append(options.loading_body);
	2688	+ }
	2689	+ modal_loading.append(modal_loading_body);
	2690	+
	2691	+ // append backdrop loading to modal content
	2692	+ modal_content.prepend(modal_loading);
	2693	+ };
	2694	+
	2695	+ // create the modal progress event handler function
	2696	+ const modal_handle_progress_event_fn = (e) => {
	2697	+ if (!e || !e.detail || !e.detail.progress_content) {
	2698	+ // do not proceed
	2699	+ return;
	2700	+ }
	2701	+
	2702	+ // identify the current loading backdrop body
	2703	+ let backdrop_body = modal_content.find('.vbo-modal-overlay-content-backdrop-body');
	2704	+ if (!backdrop_body.length) {
	2705	+ // loading body not found
	2706	+ return;
	2707	+ }
	2708	+
	2709	+ let backdrop_txt_el = $('<div></div>').addClass('vbo-modal-overlay-content-backdrop-text');
	2710	+ if (typeof e.detail.progress_content === 'string') {
	2711	+ backdrop_txt_el.html(e.detail.progress_content);
	2712	+ } else {
	2713	+ backdrop_txt_el.append(e.detail.progress_content);
	2714	+ }
	2715	+
	2716	+ let backdrop_txt_old = backdrop_body.find('.vbo-modal-overlay-content-backdrop-text');
	2717	+ if (backdrop_txt_old.length) {
	2718	+ // remove the previous text element
	2719	+ backdrop_txt_old.remove();
	2720	+ }
	2721	+
	2722	+ // set the loading progress content
	2723	+ backdrop_body.append(backdrop_txt_el);
	2724	+ };
	2725	+
	2726	+ // create the modal enlarge (toggle) function
	2727	+ const modal_enlarge_fn = (e) => {
	2728	+ // toggle modal fullscreen class
	2729	+ modal_content.toggleClass('vbo-modal-fullscreen');
	2730	+
	2731	+ // check if modal did register a resize event
	2732	+ if (options.resize_event) {
	2733	+ // fire the requested event with a delay to support the CSS transition
	2734	+ setTimeout(() => {
	2735	+ VBOCore.emitEvent(options.resize_event, {
	2736	+ content: modal_content,
	2737	+ });
	2738	+ }, 400);
	2739	+ }
	2740	+ };
	2741	+
	2742	+ // create the modal minimize function
	2743	+ const modal_minimize_fn = (e) => {
	2744	+ // invoke callback for onMinimize
	2745	+ if (typeof options.onMinimize === 'function') {
	2746	+ options.onMinimize.call(custom_modal, e);
	2747	+ }
	2748	+
	2749	+ // start minimizing animation
	2750	+ custom_modal.removeClass('vbo-restoring');
	2751	+ modal_content.removeClass('vbo-restoring');
	2752	+ custom_modal.addClass('vbo-minimizing');
	2753	+ modal_content.addClass('vbo-minimizing');
	2754	+
	2755	+ // access the modal body details data, if any
	2756	+ let details_data = modal_content_wrapper.data('details');
	2757	+ try {
	2758	+ if (details_data && typeof details_data === 'string') {
	2759	+ details_data = JSON.parse(details_data);
	2760	+ }
	2761	+ } catch(e) {
	2762	+ details_data = {};
	2763	+ }
	2764	+
	2765	+ // register delayed partial-distruction
	2766	+ setTimeout(() => {
	2767	+ // hide modal
	2768	+ custom_modal.hide();
	2769	+
	2770	+ // check if body scroll lock should be removed
	2771	+ if (options.lock_scroll) {
	2772	+ $('body').removeClass('vbo-modal-lock-scroll');
	2773	+ }
	2774	+
	2775	+ // add the minimized widget to dock
	2776	+ VBOCore.getAdminDock().addWidget(details_data, options, modal_content_wrapper, modal_destroy_fn);
	2777	+
	2778	+ // remove modal from DOM without firing the dismiss events (do not destroy the modal)
	2779	+ custom_modal.remove();
	2780	+ }, 400);
	2781	+ };
	2782	+
	2783	+ // start the modal position variables
	2784	+ var modal_pos_x = 0, modal_pos_y = 0;
	2785	+
	2786	+ // create the modal drag-start (mousedown) event handler function
	2787	+ const modal_dragstart_fn = (e) => {
	2788	+ e = e || window.event;
	2789	+ e.preventDefault();
	2790	+
	2791	+ if (typeof e.clientX === 'undefined' || typeof e.clientY === 'undefined') {
	2792	+ // unsupported
	2793	+ return;
	2794	+ }
	2795	+
	2796	+ if (e.target && !e.target.matches('.vbo-modal-overlay-cmd')) {
	2797	+ e.target.style.cursor = 'move';
	2798	+ }
	2799	+
	2800	+ // store the initial modal (cursor) position
	2801	+ modal_pos_x = e.clientX;
	2802	+ modal_pos_y = e.clientY;
	2803	+
	2804	+ // register mouseup and mousemove events
	2805	+ document.onmouseup = modal_dragstop_fn;
	2806	+ document.onmousemove = modal_dragmove_fn;
	2807	+ };
	2808	+
	2809	+ // create the modal drag-stop (mouseup) event handler function
	2810	+ const modal_dragstop_fn = (e) => {
	2811	+ e = e || window.event;
	2812	+
	2813	+ if (e.target && !e.target.matches('.vbo-modal-overlay-cmd')) {
	2814	+ e.target.style.cursor = 'auto';
	2815	+ }
	2816	+
	2817	+ // unregister mousemove event
	2818	+ if (document.onmousemove == modal_dragmove_fn) {
	2819	+ document.onmousemove = null;
	2820	+ }
	2821	+
	2822	+ // unregister mouseup event
	2823	+ if (document.onmouseup == modal_dragstop_fn) {
	2824	+ document.onmouseup = null;
	2825	+ }
	2826	+ };
	2827	+
	2828	+ // create the modal drag-move (mousemove) event handler function
	2829	+ const modal_dragmove_fn = (e) => {
	2830	+ e = e || window.event;
	2831	+ e.preventDefault();
	2832	+
	2833	+ if (typeof e.clientX === 'undefined' || typeof e.clientY === 'undefined') {
	2834	+ // unsupported
	2835	+ return;
	2836	+ }
	2837	+
	2838	+ // calculate the new modal (cursor) position
	2839	+ let new_modal_pos_x = modal_pos_x - e.clientX;
	2840	+ let new_modal_pos_y = modal_pos_y - e.clientY;
	2841	+
	2842	+ // update current modal (cursor) position
	2843	+ modal_pos_x = e.clientX;
	2844	+ modal_pos_y = e.clientY;
	2845	+
	2846	+ // find the modal element
	2847	+ let modal_element = e?.target?.closest('.vbo-modal-overlay-content');
	2848	+ if (!modal_element) {
	2849	+ return;
	2850	+ }
	2851	+
	2852	+ // set the modal position
	2853	+ modal_element.style.top = (modal_element.offsetTop - new_modal_pos_y) + 'px';
	2854	+ modal_element.style.left = (modal_element.offsetLeft - new_modal_pos_x) + 'px';
	2855	+ };
	2856	+
	2857	+ // build modal content
	2858	+ const custom_modal = $('<div></div>').addClass('vbo-modal-overlay-block vbo-modal-overlay-' + options.suffix).css('display', 'block');
	2859	+ var modal_dismiss = $('<a></a>').addClass('vbo-modal-overlay-close');
	2860	+ modal_dismiss.on('click', modal_dismiss_fn);
	2861	+ custom_modal.append(modal_dismiss);
	2862	+
	2863	+ const modal_content = $('<div></div>').addClass('vbo-modal-overlay-content vbo-modal-overlay-content-' + options.suffix);
	2864	+ if (options.extra_class && typeof options.extra_class === 'string') {
	2865	+ modal_content.addClass(options.extra_class);
	2866	+ }
	2867	+
	2868	+ // modal head and title
	2869	+ const modal_head = $('<div></div>').addClass('vbo-modal-overlay-content-head');
	2870	+ if (options.title) {
	2871	+ let modal_title = $('<span></span>').addClass('vbo-modal-overlay-content-head-title').html(options.title);
	2872	+ modal_head.append(modal_title);
	2873	+ } else {
	2874	+ modal_head.addClass('vbo-modal-head-no-title');
	2875	+ }
	2876	+ // modal head commands
	2877	+ var modal_head_cmds = $('<span></span>').addClass('vbo-modal-overlay-cmds');
	2878	+ var modal_head_close = $('<span></span>').addClass('vbo-modal-overlay-cmd vbo-modal-overlay-close-times').html('&times;');
	2879	+ modal_head_close.on('click', modal_dismiss_fn);
	2880	+ modal_head_cmds.append(modal_head_close);
	2881	+ if (options.enlargeable) {
	2882	+ var modal_head_enlarge = $('<span></span>').addClass('vbo-modal-overlay-cmd vbo-modal-overlay-cmd-enlarge').html('&square;');
	2883	+ modal_head_enlarge.on('click', modal_enlarge_fn);
	2884	+ modal_head_cmds.append(modal_head_enlarge);
	2885	+ modal_head.on('dblclick', modal_enlarge_fn);
	2886	+ }
	2887	+ if (options.minimizeable && options.event_data) {
	2888	+ // set up the minimize command
	2889	+ var modal_head_minimize = $('<span></span>').addClass('vbo-modal-overlay-cmd vbo-modal-overlay-cmd-minimize').html('&minus;');
	2890	+ modal_head_minimize.on('click', modal_minimize_fn);
	2891	+ modal_head_cmds.append(modal_head_minimize);
	2892	+ }
	2893	+ // set commands
	2894	+ modal_head.append(modal_head_cmds);
	2895	+
	2896	+ // check if the modal head should be draggable
	2897	+ if (options.draggable) {
	2898	+ // register the event(s) to allow dragging
	2899	+ modal_head.addClass('vbo-modal-head-draggable');
	2900	+ modal_head.on('contextmenu', (e) => {
	2901	+ e.preventDefault();
	2902	+ });
	2903	+ modal_head.on('mousedown', modal_dragstart_fn);
	2904	+ }
	2905	+
	2906	+ const modal_body = $('<div></div>').addClass('vbo-modal-overlay-content-body vbo-modal-overlay-content-body-scroll');
	2907	+ const modal_content_wrapper = $('<div></div>').addClass('vbo-modal-' + options.suffix + '-wrap');
	2908	+ if (options.suffix != 'widget_modal') {
	2909	+ modal_content_wrapper.addClass('vbo-modal-widget_modal-wrap');
	2910	+ }
	2911	+ if (typeof options.body === 'string') {
	2912	+ modal_content_wrapper.html(options.body);
	2913	+ } else {
	2914	+ modal_content_wrapper.append(options.body);
	2915	+ }
	2916	+ modal_body.append(modal_content_wrapper);
	2917	+
	2918	+ // modal footer
	2919	+ let modal_footer = null;
	2920	+ if (options.footer_left || options.footer_right || options.footer_center) {
	2921	+ modal_footer = $('<div></div>').addClass('vbo-modal-overlay-content-footer');
	2922	+ if (options.footer_left) {
	2923	+ let modal_footer_left = $('<div></div>').addClass('vbo-modal-overlay-content-footer-left').append(options.footer_left);
	2924	+ modal_footer.append(modal_footer_left);
	2925	+ }
	2926	+ if (options.footer_right) {
	2927	+ let modal_footer_right = $('<div></div>').addClass('vbo-modal-overlay-content-footer-right').append(options.footer_right);
	2928	+ modal_footer.append(modal_footer_right);
	2929	+ }
	2930	+ if (options.footer_center) {
	2931	+ let modal_footer_center = $('<div></div>').addClass('vbo-modal-overlay-content-footer-center').append(options.footer_center);
	2932	+ modal_footer.append(modal_footer_center);
	2933	+ }
	2934	+ }
	2935	+
	2936	+ // finalize modal contents
	2937	+ if (options.header) {
	2938	+ // append header
	2939	+ modal_content.append(modal_head);
	2940	+ }
	2941	+ // append body
	2942	+ modal_content.append(modal_body);
	2943	+ if (modal_footer) {
	2944	+ // append footer
	2945	+ modal_content.append(modal_footer);
	2946	+ }
	2947	+ custom_modal.append(modal_content);
	2948	+
	2949	+ // register to the dismiss event
	2950	+ if (options.dismiss_event) {
	2951	+ // listen to the event that will dismiss the modal
	2952	+ document.addEventListener(options.dismiss_event, function vbo_core_handle_dismiss_event(e) {
	2953	+ // make sure the same event won't propagate again, unless a new modal is displayed (multiple displayModal calls)
	2954	+ e.target.removeEventListener(e.type, vbo_core_handle_dismiss_event);
	2955	+
	2956	+ // invoke the modal dismiss function
	2957	+ modal_dismiss_fn(e);
	2958	+ });
	2959	+
	2960	+ // declare the function to detect the Escape key pressed
	2961	+ const vbo_core_dismiss_event_modal_escape = (e) => {
	2962	+ if (!e.key || e.key != 'Escape') {
	2963	+ return;
	2964	+ }
	2965	+
	2966	+ // immediately unregister from this event once fired
	2967	+ window.removeEventListener(e.type, vbo_core_dismiss_event_modal_escape);
	2968	+
	2969	+ // trigger the actual dismiss event
	2970	+ VBOCore.emitEvent(options.dismiss_event);
	2971	+ };
	2972	+
	2973	+ if (options.escape_dismiss) {
	2974	+ // listen to the Escape keyup event to dismiss the modal
	2975	+ // listen on window to allow admin-widgets to prevent the default behavior and stop the propagation
	2976	+ window.addEventListener('keyup', vbo_core_dismiss_event_modal_escape);
	2977	+ }
	2978	+ }
	2979	+
	2980	+ // register to the toggle-loading event
	2981	+ if (options.loading_event) {
	2982	+ // let a function handle it so that removing the event listener will be doable
	2983	+ document.addEventListener(options.loading_event, modal_handle_loading_event_fn);
	2984	+ if (options.progress_event) {
	2985	+ // let a function handle the progress event so that removing the listener will be doable
	2986	+ document.addEventListener(options.progress_event, modal_handle_progress_event_fn);
	2987	+ }
	2988	+ }
	2989	+
	2990	+ // append (or prepend) modal to body
	2991	+ if ($('.vbo-modal-overlay-' + options.suffix).length) {
	2992	+ $('.vbo-modal-overlay-' + options.suffix).remove();
	2993	+ }
	2994	+ if (options.body_prepend) {
	2995	+ // prepend to body
	2996	+ if ($('body > .vbo-modal-overlay-block').length) {
	2997	+ // we've got other modals prepended to the body, so go after the last one
	2998	+ $('body > .vbo-modal-overlay-block').last().after(custom_modal);
	2999	+ } else {
	3000	+ // place the modal right as the first child node of body
	3001	+ $('body').prepend(custom_modal);
	3002	+ }
	3003	+ } else {
	3004	+ // append to body
	3005	+ $('body').append(custom_modal);
	3006	+ }
	3007	+
	3008	+ // check if scroll should be locked on the whole page body for a "sticky" modal
	3009	+ if (options.lock_scroll) {
	3010	+ $('body').addClass('vbo-modal-lock-scroll');
	3011	+ }
	3012	+
	3013	+ if (typeof bindDetails === 'object') {
	3014	+ try {
	3015	+ // bind widget details data
	3016	+ modal_content_wrapper.data('details', JSON.stringify(bindDetails));
	3017	+ } catch(e) {
	3018	+ // do nothing
	3019	+ }
	3020	+ }
	3021	+
	3022	+ // return the content wrapper element of the new modal
	3023	+ return modal_content_wrapper;
	3024	+ }
	3025	+
	3026	+ /**
	3027	+ * Debounce technique to group a flurry of events into one single event.
	3028	+ */
	3029	+ static debounceEvent(func, wait, immediate) {
	3030	+ var timeout;
	3031	+ return function() {
	3032	+ var context = this, args = arguments;
	3033	+ var later = function() {
	3034	+ timeout = null;
	3035	+ if (!immediate) func.apply(context, args);
	3036	+ };
	3037	+ var callNow = immediate && !timeout;
	3038	+ clearTimeout(timeout);
	3039	+ timeout = setTimeout(later, wait);
	3040	+ if (callNow) {
	3041	+ func.apply(context, args);
	3042	+ }
	3043	+ }
	3044	+ }
	3045	+
	3046	+ /**
	3047	+ * Throttle guarantees a constant flow of events at a given time interval.
	3048	+ * Runs immediately when the event takes place, but can be delayed.
	3049	+ */
	3050	+ static throttleEvent(method, delay) {
	3051	+ var time = Date.now();
	3052	+ return function() {
	3053	+ if ((time + delay - Date.now()) < 0) {
	3054	+ method();
	3055	+ time = Date.now();
	3056	+ }
	3057	+ }
	3058	+ }
	3059	+
	3060	+ /**
	3061	+ * Alternative throttle technique for event listeners.
	3062	+ *
	3063	+ * @param function callback the callback to invoke.
	3064	+ * @param int time the time (in ms) to throttle.
	3065	+ *
	3066	+ * @return void
	3067	+ *
	3068	+ * @since 1.6.8
	3069	+ */
	3070	+ static throttleTimer(callback, time) {
	3071	+ if (VBOCore.throttle_timer) {
	3072	+ // prevent more executions
	3073	+ return;
	3074	+ }
	3075	+
	3076	+ // turn throttle timer on
	3077	+ VBOCore.throttle_timer = true;
	3078	+
	3079	+ setTimeout(() => {
	3080	+ // run the callback with the given delay
	3081	+ callback();
	3082	+
	3083	+ // turn throttle timer off
	3084	+ VBOCore.throttle_timer = false;
	3085	+ }, time);
	3086	+ }
	3087	+
	3088	+ /**
	3089	+ * Tells whether localStorage is supported.
	3090	+ *
	3091	+ * @return boolean
	3092	+ */
	3093	+ static storageSupported() {
	3094	+ return typeof localStorage !== 'undefined';
	3095	+ }
	3096	+
	3097	+ /**
	3098	+ * Gets an item from localStorage.
	3099	+ *
	3100	+ * @param string keyName the storage key identifier.
	3101	+ *
	3102	+ * @return any
	3103	+ */
	3104	+ static storageGetItem(keyName) {
	3105	+ if (!VBOCore.storageSupported()) {
	3106	+ return null;
	3107	+ }
	3108	+
	3109	+ return localStorage.getItem(keyName);
	3110	+ }
	3111	+
	3112	+ /**
	3113	+ * Sets an item to localStorage.
	3114	+ *
	3115	+ * @param string keyName the storage key identifier.
	3116	+ * @param any value the value to store.
	3117	+ *
	3118	+ * @return boolean
	3119	+ */
	3120	+ static storageSetItem(keyName, value) {
	3121	+ if (!VBOCore.storageSupported()) {
	3122	+ return false;
	3123	+ }
	3124	+
	3125	+ try {
	3126	+ if (typeof value === 'object') {
	3127	+ value = JSON.stringify(value);
	3128	+ }
	3129	+
	3130	+ localStorage.setItem(keyName, value);
	3131	+ } catch(e) {
	3132	+ console.error(e);
	3133	+ return false;
	3134	+ }
	3135	+
	3136	+ return true;
	3137	+ }
	3138	+
	3139	+ /**
	3140	+ * Removes an item from localStorage.
	3141	+ *
	3142	+ * @param string keyName the storage key identifier.
	3143	+ *
	3144	+ * @return boolean
	3145	+ */
	3146	+ static storageRemoveItem(keyName) {
	3147	+ if (!VBOCore.storageSupported()) {
	3148	+ return false;
	3149	+ }
	3150	+
	3151	+ localStorage.removeItem(keyName);
	3152	+
	3153	+ return true;
	3154	+ }
	3155	+
	3156	+ /**
	3157	+ * Returns the name of the storage identifier for the given scope.
	3158	+ *
	3159	+ * @param string scope the admin menu scope.
	3160	+ *
	3161	+ * @return string the requested admin menu storage identifier.
	3162	+ */
	3163	+ static getStorageScopeName(scope) {
	3164	+ let storage_scope_name = VBOCore.options.admin_menu_actions_nm;
	3165	+
	3166	+ if (typeof scope === 'string' && scope.length) {
	3167	+ if (scope.indexOf('.') !== 0) {
	3168	+ scope = '.' + scope;
	3169	+ }
	3170	+ storage_scope_name += scope;
	3171	+ }
	3172	+
	3173	+ return storage_scope_name;
	3174	+ }
	3175	+
	3176	+ /**
	3177	+ * Returns a list of admin menu action objects or an empty array.
	3178	+ *
	3179	+ * @param string scope the admin menu scope.
	3180	+ *
	3181	+ * @return Array
	3182	+ */
	3183	+ static getAdminMenuActions(scope) {
	3184	+ let menu_actions = VBOCore.storageGetItem(VBOCore.getStorageScopeName(scope));
	3185	+
	3186	+ if (!menu_actions) {
	3187	+ return [];
	3188	+ }
	3189	+
	3190	+ try {
	3191	+ menu_actions = JSON.parse(menu_actions);
	3192	+ if (!Array.isArray(menu_actions) || !menu_actions.length) {
	3193	+ menu_actions = [];
	3194	+ }
	3195	+ } catch(e) {
	3196	+ return [];
	3197	+ }
	3198	+
	3199	+ return menu_actions;
	3200	+ }
	3201	+
	3202	+ /**
	3203	+ * Builds an admin menu action object with a proper href property.
	3204	+ *
	3205	+ * @param object action the action to build.
	3206	+ *
	3207	+ * @return object
	3208	+ */
	3209	+ static buildAdminMenuAction(action) {
	3210	+ if (typeof action !== 'object' || !action || !action.hasOwnProperty('name')) {
	3211	+ throw new Error('Invalid action object');
	3212	+ }
	3213	+
	3214	+ var action_base = action.hasOwnProperty('href') && typeof action['href'] == 'string' ? action['href'] : window.location.href;
	3215	+ var action_url;
	3216	+
	3217	+ if (action_base.toLowerCase().indexOf('javascript') === 0 && action.hasOwnProperty('widget')) {
	3218	+ // no need to prepare the action URL ("JavaScript: void(0)") as the link will use a JS callback
	3219	+ return action;
	3220	+ }
	3221	+
	3222	+ if (action_base.indexOf('http') !== 0) {
	3223	+ // relative URL
	3224	+ action_url = new URL(action_base, window.location.href);
	3225	+ } else {
	3226	+ // absolute URL
	3227	+ action_url = new URL(action_base);
	3228	+ }
	3229	+
	3230	+ // build proper href with a relative URL
	3231	+ action['href'] = action_url.pathname + action_url.search;
	3232	+
	3233	+ return action;
	3234	+ }
	3235	+
	3236	+ /**
	3237	+ * Registers an admin menu action object.
	3238	+ *
	3239	+ * @param object action the action to build.
	3240	+ * @param string scope the admin menu scope.
	3241	+ *
	3242	+ * @return boolean
	3243	+ */
	3244	+ static registerAdminMenuAction(action, scope) {
	3245	+ // build menu action object
	3246	+ let menu_action_entry = VBOCore.buildAdminMenuAction(action);
	3247	+
	3248	+ let menu_actions = VBOCore.getAdminMenuActions(scope);
	3249	+
	3250	+ // make sure we are not pushing a duplicate and count pinned actions
	3251	+ let pinned_actions = 0;
	3252	+ let unpinned_index = [];
	3253	+ for (let i = 0; i < menu_actions.length; i++) {
	3254	+ // avoid duplicate entries
	3255	+ if (!menu_action_entry.hasOwnProperty('widget') && menu_actions[i]['href'] == menu_action_entry['href']) {
	3256	+ // duplicate link
	3257	+ return false;
	3258	+ }
	3259	+ if (menu_action_entry.hasOwnProperty('widget') && menu_actions[i].hasOwnProperty('widget') && menu_actions[i]['widget'] == menu_action_entry['widget']) {
	3260	+ // duplicate widget
	3261	+ return false;
	3262	+ }
	3263	+ if (menu_actions[i].hasOwnProperty('pinned') && menu_actions[i]['pinned']) {
	3264	+ pinned_actions++;
	3265	+ } else {
	3266	+ unpinned_index.push(i);
	3267	+ }
	3268	+ }
	3269	+
	3270	+ if (pinned_actions >= VBOCore.options.admin_menu_maxactions) {
	3271	+ // no more space to register a new menu action for this admin menu
	3272	+ return false;
	3273	+ }
	3274	+
	3275	+ // splice or pop before prepending to keep current indexes
	3276	+ let tot_menu_actions = menu_actions.length;
	3277	+ if (++tot_menu_actions > VBOCore.options.admin_menu_maxactions) {
	3278	+ if (unpinned_index.length) {
	3279	+ menu_actions.splice(unpinned_index[unpinned_index.length - 1], 1);
	3280	+ } else {
	3281	+ menu_actions.pop();
	3282	+ }
	3283	+ }
	3284	+
	3285	+ // prepend new admin menu action
	3286	+ menu_actions.unshift(menu_action_entry);
	3287	+
	3288	+ return VBOCore.storageSetItem(VBOCore.getStorageScopeName(scope), menu_actions);
	3289	+ }
	3290	+
	3291	+ /**
	3292	+ * Updates an existing admin menu action object.
	3293	+ *
	3294	+ * @param object action the action to build.
	3295	+ * @param string scope the admin menu scope.
	3296	+ * @param number index optional menu action index.
	3297	+ *
	3298	+ * @return boolean
	3299	+ */
	3300	+ static updateAdminMenuAction(action, scope, index) {
	3301	+ // build menu action object
	3302	+ let menu_action_entry = VBOCore.buildAdminMenuAction(action);
	3303	+
	3304	+ let menu_actions = VBOCore.getAdminMenuActions(scope);
	3305	+
	3306	+ if (!menu_actions.length) {
	3307	+ return false;
	3308	+ }
	3309	+
	3310	+ if (typeof index === 'undefined') {
	3311	+ // find the proper index to update by href
	3312	+ for (let i = 0; i < menu_actions.length; i++) {
	3313	+ if (menu_actions[i].hasOwnProperty('widget') && menu_action_entry.hasOwnProperty('widget') && menu_actions[i]['widget'] == menu_action_entry['widget']) {
	3314	+ // existing entry for widget found
	3315	+ index = i;
	3316	+ break;
	3317	+ } else if (!menu_action_entry.hasOwnProperty('widget') && menu_actions[i]['href'] == menu_action_entry['href']) {
	3318	+ // existing entry for link found
	3319	+ index = i;
	3320	+ break;
	3321	+ }
	3322	+ }
	3323	+ }
	3324	+
	3325	+ if (isNaN(index) || !(index in menu_actions)) {
	3326	+ // menu entry index not found
	3327	+ return false;
	3328	+ }
	3329	+
	3330	+ menu_actions[index] = menu_action_entry;
	3331	+
	3332	+ return VBOCore.storageSetItem(VBOCore.getStorageScopeName(scope), menu_actions);
	3333	+ }
	3334	+
	3335	+ /**
	3336	+ * Checks if the current menu actions should be filled with some other actions.
	3337	+ * No update is made over the Local Storage through this method.
	3338	+ *
	3339	+ * @param array menu_actions menu actions to fill.
	3340	+ * @param array widgets_actions default actions to use for filling.
	3341	+ * @param string scope the admin menu scope.
	3342	+ *
	3343	+ * @return array the menu actions eventually filled.
	3344	+ */
	3345	+ static fillAdminMenuActions(menu_actions, widgets_actions, scope) {
	3346	+ if (!Array.isArray(menu_actions) || !Array.isArray(widgets_actions)) {
	3347	+ return [];
	3348	+ }
	3349	+
	3350	+ if (!menu_actions.length || !widgets_actions.length || menu_actions.length >= VBOCore.options.admin_menu_maxactions) {
	3351	+ return menu_actions;
	3352	+ }
	3353	+
	3354	+ var current_widgets = [];
	3355	+ menu_actions.forEach((action, index) => {
	3356	+ current_widgets.push(action['widget']);
	3357	+ });
	3358	+
	3359	+ for (var i = 0; i < widgets_actions.length; i++) {
	3360	+ if (menu_actions.length >= VBOCore.options.admin_menu_maxactions) {
	3361	+ // abort for filling completed
	3362	+ break;
	3363	+ }
	3364	+
	3365	+ if (!widgets_actions[i].hasOwnProperty('widget')) {
	3366	+ // action must be for a widget
	3367	+ continue;
	3368	+ }
	3369	+
	3370	+ if (current_widgets.includes(widgets_actions[i]['widget'])) {
	3371	+ // there cannot be duplicate entries
	3372	+ continue;
	3373	+ }
	3374	+
	3375	+ // fill menu action
	3376	+ menu_actions.push(widgets_actions[i]);
	3377	+ }
	3378	+
	3379	+ return menu_actions;
	3380	+ }
	3381	+
	3382	+ /**
	3383	+ * Formats a date object by accepting "Y", "m" and "d".
	3384	+ *
	3385	+ * @param Date date The date object to format.
	3386	+ * @param string format The date format to use.
	3387	+ *
	3388	+ * @return string
	3389	+ */
	3390	+ static formatDate(date, format) {
	3391	+ if (!date instanceof Date) {
	3392	+ throw new Error('Invalid date object given.');
	3393	+ }
	3394	+
	3395	+ if (!format || typeof format !== 'string') {
	3396	+ // default to military format
	3397	+ format = 'Y-m-d';
	3398	+ }
	3399	+
	3400	+ let year = date.getFullYear();
	3401	+ let month = (date.getMonth() + 1) + '';
	3402	+ let mday = (date.getDate()) + '';
	3403	+
	3404	+ month = month.length < 2 ? '0' + month : month;
	3405	+ mday = mday.length < 2 ? '0' + mday : mday;
	3406	+
	3407	+ // use a regex to capture the date separator and format identifiers
	3408	+ const regexp = /^([ymd])([\s\.\-\/])([ymd])([\s\.\-\/])([ymd])$/gi;
	3409	+
	3410	+ // turn the iterable iterator object into an array by using the spread syntax
	3411	+ let formatArray = [...format.matchAll(regexp)];
	3412	+
	3413	+ if (!formatArray.length || !Array.isArray(formatArray[0]) || formatArray[0].length != 6) {
	3414	+ throw new Error('Invalid date format given.');
	3415	+ }
	3416	+
	3417	+ let firstIdentifier = (formatArray[0][1] + '').toLowerCase();
	3418	+ let separatorChar = formatArray[0][2];
	3419	+ let secondIdentifier = (formatArray[0][3] + '').toLowerCase();
	3420	+ let thirdIdentifier = (formatArray[0][5] + '').toLowerCase();
	3421	+
	3422	+ if (!separatorChar) {
	3423	+ throw new Error('Invalid date format separator given.');
	3424	+ }
	3425	+
	3426	+ let dateParts = [];
	3427	+
	3428	+ if (firstIdentifier == 'y') {
	3429	+ dateParts.push(year);
	3430	+ } else if (firstIdentifier == 'm') {
	3431	+ dateParts.push(month);
	3432	+ } else {
	3433	+ dateParts.push(mday);
	3434	+ }
	3435	+
	3436	+ if (secondIdentifier == 'y') {
	3437	+ dateParts.push(year);
	3438	+ } else if (secondIdentifier == 'm') {
	3439	+ dateParts.push(month);
	3440	+ } else {
	3441	+ dateParts.push(mday);
	3442	+ }
	3443	+
	3444	+ if (thirdIdentifier == 'y') {
	3445	+ dateParts.push(year);
	3446	+ } else if (thirdIdentifier == 'm') {
	3447	+ dateParts.push(month);
	3448	+ } else {
	3449	+ dateParts.push(mday);
	3450	+ }
	3451	+
	3452	+ return dateParts.join(separatorChar);
	3453	+ }
	3454	+
	3455	+ /**
	3456	+ * Proxy to access the VBOCurrency object.
	3457	+ *
	3458	+ * @param object options The currency options.
	3459	+ *
	3460	+ * @return VBOCurrency
	3461	+ */
	3462	+ static getCurrency(options) {
	3463	+ return VBOCurrency.getInstance(options);
	3464	+ }
	3465	+
	3466	+ /**
	3467	+ * Proxy to access the VBOAdminDock object.
	3468	+ *
	3469	+ * @return VBOAdminDock
	3470	+ */
	3471	+ static getAdminDock() {
	3472	+ return VBOAdminDock.getInstance();
	3473	+ }
	3474	+ }
	3475	+
	3476	+ /**
	3477	+ * These used to be private static properties (static #options),
	3478	+ * but they are only supported by quite recent browsers (especially Safari).
	3479	+ * It's too premature, so we decided to keep the class properties public
	3480	+ * without declaring them as static inside the class declaration.
	3481	+ *
	3482	+ * @var object
	3483	+ */
	3484	+ VBOCore.options = CORE_OPTIONS || {
	3485	+ is_vbo: false,
	3486	+ is_vcm: false,
	3487	+ cms: 'wordpress',
	3488	+ widget_ajax_uri: null,
	3489	+ assets_ajax_uri: null,
	3490	+ multitask_ajax_uri: null,
	3491	+ watchdata_ajax_uri: null,
	3492	+ current_page: null,
	3493	+ current_page_uri: null,
	3494	+ root_uri: '/',
	3495	+ client: 'admin',
	3496	+ panel_opts: {},
	3497	+ admin_widgets: [],
	3498	+ events_delegated: [],
	3499	+ notif_audio_url: '',
	3500	+ active_listeners: {},
	3501	+ tn_texts: {
	3502	+ notifs_enabled: 'Browser notifications are enabled!',
	3503	+ notifs_disabled: 'Browser notifications are disabled',
	3504	+ notifs_disabled_help: "Could not enable browser notifications.\nThis feature is available only in secure contexts (HTTPS).",
	3505	+ admin_widget: 'Admin widget',
	3506	+ congrats: 'Congratulations!',
	3507	+ },
	3508	+ default_loading_body: '....',
	3509	+ multitask_save_event: 'vbo-admin-multitask-save',
	3510	+ multitask_open_event: 'vbo-admin-multitask-open',
	3511	+ multitask_close_event: 'vbo-admin-multitask-close',
	3512	+ multitask_shortcut_ev: 'vbo_multitask_shortcut',
	3513	+ multitask_searchfs_ev: 'vbo_multitask_search_focus',
	3514	+ widget_modal_rendered: 'vbo-admin-widget-modal-rendered',
	3515	+ widget_modal_dismissed: 'vbo-widget-modal-dismissed',
	3516	+ admin_menu_maxactions: 3,
	3517	+ admin_menu_actions_nm: 'vikbooking.admin_menu.actions',
	3518	+ service_worker_path: '',
	3519	+ service_worker_scope: './',
	3520	+ push: {
	3521	+ application_key: '',
	3522	+ ajax_url: '',
	3523	+ },
	3524	+ push_options: {
	3525	+ storage_endp_id: 'vbo_push_subscr_endp',
	3526	+ allowed_notif_types: [
	3527	+ 'Book',
	3528	+ 'Modify',
	3529	+ 'Cancel',
	3530	+ 'Request',
	3531	+ 'CancelRequest',
	3532	+ 'Inquiry',
	3533	+ 'CancelInquiry',
	3534	+ 'Chat',
	3535	+ 'Info',
	3536	+ ],
	3537	+ },
	3538	+ };
	3539	+
	3540	+ /**
	3541	+ * @var bool
	3542	+ */
	3543	+ VBOCore.side_panel_on = false;
	3544	+
	3545	+ /**
	3546	+ * @var bool
	3547	+ * @since 1.6.8
	3548	+ */
	3549	+ VBOCore.throttle_timer = false;
	3550	+
	3551	+ /**
	3552	+ * @var array
	3553	+ */
	3554	+ VBOCore.notifications = [];
	3555	+
	3556	+ /**
	3557	+ * @var object
	3558	+ */
	3559	+ VBOCore.widgets_watch_data = null;
	3560	+
	3561	+ /**
	3562	+ * @var number
	3563	+ */
	3564	+ VBOCore.watch_data_interval = null;
	3565	+
	3566	+ /**
	3567	+ * @var object
	3568	+ * @since 1.6.3
	3569	+ */
	3570	+ VBOCore.broadcast_watch_data = null;
	3571	+
	3572	+ /**
	3573	+ * @var object
	3574	+ * @since 1.6.5
	3575	+ */
	3576	+ VBOCore.broadcast_push_data = null;
	3577	+
	3578	+ /**
	3579	+ * @var object
	3580	+ * @since 1.6.8
	3581	+ */
	3582	+ VBOCore.broadcast_watch_events = null;
	3583	+
	3584	+ /**
	3585	+ * @var array<object>
	3586	+ * @since 1.6.5
	3587	+ */
	3588	+ VBOCore.widgets_pushed_data = [];
	3589	+
	3590	+ /**
	3591	+ * Checks if the KeyBoard event matches the given shortcut.
	3592	+ *
	3593	+ * @param array keys The shortcut representation.
	3594	+ *
	3595	+ * @return boolean True if matches, otherwise false.
	3596	+ *
	3597	+ * @since 1.7.0
	3598	+ */
	3599	+ KeyboardEvent.prototype.shortcut = function(keys) {
	3600	+ // get modifiers list
	3601	+ var modifiers = keys.slice(0);
	3602	+ // pop character from modifiers
	3603	+ var keyCode = modifiers.pop();
	3604	+
	3605	+ if (typeof keyCode === 'string') {
	3606	+ // get ASCII
	3607	+ keyCode = keyCode.toUpperCase().charCodeAt(0);
	3608	+ }
	3609	+
	3610	+ // make sure the modifiers are lower case
	3611	+ modifiers = modifiers.map(function(mod) {
	3612	+ return mod.toLowerCase();
	3613	+ });
	3614	+
	3615	+ var ok = false;
	3616	+
	3617	+ // validate key code
	3618	+ if (this.keyCode == keyCode) {
	3619	+ // validate modifiers
	3620	+ ok = true;
	3621	+ var lookup = ['meta', 'shift', 'alt', 'ctrl'];
	3622	+
	3623	+ for (var i = 0; i < lookup.length && ok; i++) {
	3624	+ // check if modifiers is pressed
	3625	+ var mod = this[lookup[i] + 'Key'];
	3626	+
	3627	+ if (mod) {
	3628	+ // if pressed, the shortcut must specify it
	3629	+ ok &= modifiers.indexOf(lookup[i]) !== -1;
	3630	+ } else {
	3631	+ // if not pressed, the shortcut must not include it
	3632	+ ok &= modifiers.indexOf(lookup[i]) === -1;
	3633	+ }
	3634	+ }
	3635	+ }
	3636	+
	3637	+ return ok;
	3638	+ }
	3639	+
	3640	+ /**
	3641	+ * VBOCurrency class implementation.
	3642	+ */
	3643	+ w['VBOCurrency'] = class VBOCurrency {
	3644	+ /**
	3645	+ * Singleton entry-point.
	3646	+ *
	3647	+ * @see construct()
	3648	+ */
	3649	+ static getInstance(options) {
	3650	+ if (typeof VBOCurrency.instance === 'undefined') {
	3651	+ VBOCurrency.instance = new VBOCurrency(options);
	3652	+ }
	3653	+
	3654	+ return VBOCurrency.instance;
	3655	+ }
	3656	+
	3657	+ /**
	3658	+ * Class constructor.
	3659	+ *
	3660	+ * @param object options The currency options object:
	3661	+ * - symbol string The currency symbol (such as €, $, £ and so on).
	3662	+ * - position int The position of the currency (1 before, 2 after). In case the amount is negative
	3663	+ * the space between the currency and the amount won't be used.
	3664	+ * - decimals string The decimals separator character ("." or ",").
	3665	+ * - thousands string The thousands separator character ("," or ".").
	3666	+ * - digits int The number of decimal digits.
	3667	+ * - noDecimals int Whether empty decimals should be omitted (1 true, 0 false).
	3668	+ * - conversionRate float The currency conversion rate.
	3669	+ */
	3670	+ constructor(options) {
	3671	+ this.setOptions(options);
	3672	+ }
	3673	+
	3674	+ /**
	3675	+ * Sets the currency options.
	3676	+ *
	3677	+ * @param object options The currency options object.
	3678	+ *
	3679	+ * @see construct()
	3680	+ */
	3681	+ setOptions(options) {
	3682	+ if (options === undefined) {
	3683	+ options = {};
	3684	+ }
	3685	+
	3686	+ // define default currency options for eventually merging with new options
	3687	+ let def_symbol = this.symbol !== undefined ? this.symbol : '$';
	3688	+ let def_position = this.position !== undefined ? this.position : 1;
	3689	+ let def_decimals = this.decimals !== undefined ? this.decimals : '.';
	3690	+ let def_thousands = this.thousands !== undefined ? this.thousands : ',';
	3691	+ let def_digits = this.digits !== undefined ? this.digits : 2;
	3692	+ let def_no_decimals = this.noDecimals !== undefined ? this.noDecimals : 1;
	3693	+ let def_conv_rate = this.conversionRate !== undefined ? this.conversionRate : 1;
	3694	+
	3695	+ // normalize option properties
	3696	+ if (options.position && /^[a-zA-Z]+$/.test(options.position)) {
	3697	+ // convert alphanumeric position to integer
	3698	+ options.position = options.position.toLowerCase() === 'after' ? 2 : 1;
	3699	+ }
	3700	+
	3701	+ // set currency options
	3702	+ this.symbol = (options.hasOwnProperty('symbol') ? options.symbol : def_symbol);
	3703	+ this.position = (options.hasOwnProperty('position') ? options.position : def_position);
	3704	+ this.decimals = (options.hasOwnProperty('decimals') ? options.decimals : def_decimals);
	3705	+ this.thousands = (options.hasOwnProperty('thousands') ? options.thousands : def_thousands);
	3706	+ this.digits = (options.hasOwnProperty('digits') ? parseInt(options.digits) : def_digits);
	3707	+ this.noDecimals = (options.hasOwnProperty('noDecimals') ? parseInt(options.noDecimals) : def_no_decimals);
	3708	+ this.conversionRate = Math.abs((options.hasOwnProperty('conversionRate') ? parseFloat(options.conversionRate) : 1));
	3709	+ }
	3710	+
	3711	+ /**
	3712	+ * Gets the current currency options.
	3713	+ *
	3714	+ * @return object
	3715	+ */
	3716	+ getOptions() {
	3717	+ let options = {};
	3718	+
	3719	+ Object.keys(this).forEach((option) => {
	3720	+ if (this.hasOwnProperty(option)) {
	3721	+ options[option] = this[option];
	3722	+ }
	3723	+ });
	3724	+
	3725	+ return options;
	3726	+ }
	3727	+
	3728	+ /**
	3729	+ * Formats the given price according to the configuration preferences.
	3730	+ *
	3731	+ * @param float price The price to format.
	3732	+ * @param object options Temporarily overrides the currency options.
	3733	+ *
	3734	+ * @return string The formatted price.
	3735	+ */
	3736	+ format(price, options) {
	3737	+ // merge currency settings
	3738	+ options = Object.assign(this.getOptions(), (options || {}));
	3739	+
	3740	+ let no_decimals = options.noDecimals;
	3741	+ let dig = options.digits;
	3742	+
	3743	+ if (no_decimals && parseInt(price) == price) {
	3744	+ // no decimal digits in case of empty decimals
	3745	+ dig = 0;
	3746	+ }
	3747	+
	3748	+ price = parseFloat(price) / options.conversionRate;
	3749	+
	3750	+ // check whether the price is negative
	3751	+ const isNegative = price < 0;
	3752	+
	3753	+ // adjust to given decimals
	3754	+ price = Math.abs(price).toFixed(dig);
	3755	+
	3756	+ let _d = options.decimals;
	3757	+ let _t = options.thousands;
	3758	+
	3759	+ // make sure the decimal separator is a valid character
	3760	+ if (!_d.match(/[.,\s]/)) {
	3761	+ // revert to default one
	3762	+ _d = '.';
	3763	+ }
	3764	+
	3765	+ // make sure the thousands separator is a valid character
	3766	+ if (!_t.match(/[.,\s]/)) {
	3767	+ // revert to default one
	3768	+ _t = ',';
	3769	+ }
	3770	+
	3771	+ // make sure both the separators are not equals
	3772	+ if (_d == _t) {
	3773	+ _t = _d == ',' ? '.' : ',';
	3774	+ }
	3775	+
	3776	+ price = price.split('.');
	3777	+
	3778	+ price[0] = price[0].replace(/./g, function(c, i, a) {
	3779	+ return i > 0 && (a.length - i) % 3 === 0 ? _t + c : c;
	3780	+ });
	3781	+
	3782	+ if (isNegative) {
	3783	+ // re-add negative sign
	3784	+ price[0] = '-' + price[0];
	3785	+ }
	3786	+
	3787	+ if (price.length > 1) {
	3788	+ price = price[0] + _d + price[1];
	3789	+ } else {
	3790	+ price = price[0];
	3791	+ }
	3792	+
	3793	+ if (Math.abs(options.position) == 1) {
	3794	+ // do not use space in case the position is "-1"
	3795	+ return options.symbol + (options.position == 1 ? ' ' : '') + price;
	3796	+ }
	3797	+
	3798	+ // do not use space in case the position is "-2"
	3799	+ return price + (options.position == 2 ? ' ' : '') + options.symbol;
	3800	+ }
	3801	+
	3802	+ /**
	3803	+ * Displays the given (formatted) price according to the currency settings.
	3804	+ *
	3805	+ * @param string price The price to display (expected to be already formatted).
	3806	+ * @param object options Temporarily overrides the currency options.
	3807	+ *
	3808	+ * @return string The currency and price final string to display.
	3809	+ *
	3810	+ * @since 1.8.3
	3811	+ */
	3812	+ display(price, options) {
	3813	+ // merge currency settings
	3814	+ options = Object.assign(this.getOptions(), (options || {}));
	3815	+
	3816	+ if (Math.abs(options.position) == 1) {
	3817	+ // do not use space in case the position is "-1"
	3818	+ return options.symbol + (options.position == 1 ? ' ' : '') + price;
	3819	+ }
	3820	+
	3821	+ // do not use space in case the position is "-2"
	3822	+ return price + (options.position == 2 ? ' ' : '') + options.symbol;
	3823	+ }
	3824	+
	3825	+ /**
	3826	+ * Safely sums 2 prices (a + b).
	3827	+ *
	3828	+ * @param float a
	3829	+ * @param float b
	3830	+ *
	3831	+ * @return The resulting sum.
	3832	+ */
	3833	+ sum(a, b) {
	3834	+ // get rid of decimals for higher precision
	3835	+ a *= Math.pow(10, this.digits);
	3836	+ b *= Math.pow(10, this.digits);
	3837	+
	3838	+ // do sum and go back to decimal
	3839	+ return (Math.round(a) + Math.round(b)) / Math.pow(10, this.digits);
	3840	+ }
	3841	+
	3842	+ /**
	3843	+ * Safely subtracts 2 prices (a - b).
	3844	+ *
	3845	+ * @param float a
	3846	+ * @param float b
	3847	+ *
	3848	+ * @return The resulting difference.
	3849	+ */
	3850	+ diff(a, b) {
	3851	+ // get rid of decimals for higher precision
	3852	+ a *= Math.pow(10, this.digits);
	3853	+ b *= Math.pow(10, this.digits);
	3854	+
	3855	+ // do difference and go back to decimal
	3856	+ return (Math.round(a) - Math.round(b)) / Math.pow(10, this.digits);
	3857	+ }
	3858	+
	3859	+ /**
	3860	+ * Safely multiplies 2 prices (a * b).
	3861	+ *
	3862	+ * @param float a
	3863	+ * @param float b
	3864	+ *
	3865	+ * @return The resulting multiplication.
	3866	+ */
	3867	+ multiply(a, b) {
	3868	+ // get rid of decimals for higher precision
	3869	+ a *= Math.pow(10, this.digits);
	3870	+ b *= Math.pow(10, this.digits);
	3871	+
	3872	+ // do multiplication and go back to decimal
	3873	+ return (Math.round(a) * Math.round(b)) / Math.pow(10, this.digits * 2);
	3874	+ }
	3875	+ }
	3876	+
	3877	+ /**
	3878	+ * VBOAdminDock class implementation.
	3879	+ */
	3880	+ w['VBOAdminDock'] = class VBOAdminDock {
	3881	+ /**
	3882	+ * Singleton entry-point.
	3883	+ *
	3884	+ * @see construct()
	3885	+ */
	3886	+ static getInstance(options) {
	3887	+ if (typeof VBOAdminDock.instance === 'undefined') {
	3888	+ VBOAdminDock.instance = new VBOAdminDock(options);
	3889	+ }
	3890	+
	3891	+ return VBOAdminDock.instance;
	3892	+ }
	3893	+
	3894	+ /**
	3895	+ * Class constructor.
	3896	+ *
	3897	+ * @param object options The admin dock options object.
	3898	+ */
	3899	+ constructor(options) {
	3900	+ // set options
	3901	+ this.setOptions(options);
	3902	+
	3903	+ // start empty dock elements property
	3904	+ this._elements = [];
	3905	+
	3906	+ // set dock storage identifier property
	3907	+ this._storageId = 'vikbooking.admin_dock.elements';
	3908	+
	3909	+ // set event name for updating the dock element badge counters
	3910	+ this._updateBadgeEv = 'vbo-admin-dock-update-badge';
	3911	+
	3912	+ // build dock node
	3913	+ this.buildDockNode();
	3914	+
	3915	+ // load dock elements
	3916	+ this.loadDockElements();
	3917	+ }
	3918	+
	3919	+ /**
	3920	+ * Sets the options.
	3921	+ *
	3922	+ * @param object options The dock options object.
	3923	+ *
	3924	+ * @see construct()
	3925	+ */
	3926	+ setOptions(options) {
	3927	+ if (options === undefined) {
	3928	+ options = {};
	3929	+ }
	3930	+
	3931	+ // default options
	3932	+ let defaultOptions = {
	3933	+ dockDisplayStyle: 'flex',
	3934	+ };
	3935	+
	3936	+ // set options
	3937	+ this._options = Object.assign(defaultOptions, options);
	3938	+ }
	3939	+
	3940	+ /**
	3941	+ * Gets the current dock options.
	3942	+ *
	3943	+ * @return object
	3944	+ */
	3945	+ getOptions() {
	3946	+ let options = {};
	3947	+
	3948	+ Object.keys(this._options).forEach((option) => {
	3949	+ if (this._options.hasOwnProperty(option)) {
	3950	+ options[option] = this._options[option];
	3951	+ }
	3952	+ });
	3953	+
	3954	+ return options;
	3955	+ }
	3956	+
	3957	+ /**
	3958	+ * Builds the admin dock and adds it to the DOM.
	3959	+ *
	3960	+ * @return HTMLElement
	3961	+ */
	3962	+ buildDockNode() {
	3963	+ if (this._dock) {
	3964	+ return;
	3965	+ }
	3966	+
	3967	+ // create element
	3968	+ this._dock = document.createElement('div');
	3969	+ this._dock.classList.add('vbo-admin-dock-wrapper');
	3970	+
	3971	+ // listen to the event for updating the element badge counters
	3972	+ document.addEventListener(this._updateBadgeEv, this.updateElementsBadgeCounter);
	3973	+
	3974	+ // append element to body
	3975	+ document.querySelector('body').appendChild(this._dock);
	3976	+
	3977	+ return this._dock;
	3978	+ }
	3979	+
	3980	+ /**
	3981	+ * Returns the admin dock node.
	3982	+ *
	3983	+ * @return HTMLElement
	3984	+ */
	3985	+ getDockNode() {
	3986	+ return this._dock || this.buildDockNode();
	3987	+ }
	3988	+
	3989	+ /**
	3990	+ * Removes a given element index from the dock and saves on local storage.
	3991	+ * This method should be called after having removed the element from DOM.
	3992	+ *
	3993	+ * @param number index The element's array index to remove.
	3994	+ *
	3995	+ * @return bool True if the localStorage was updated or false.
	3996	+ */
	3997	+ removeDockElement(index) {
	3998	+ // access the previous element
	3999	+ let previousElement = this._elements[index];
	4000	+
	4001	+ // splice the elements list
	4002	+ this._elements.splice(index, 1);
	4003	+
	4004	+ if (!this._elements.length) {
	4005	+ // hide the dock
	4006	+ this.hideDock();
	4007	+ } else {
	4008	+ // reset dock element indexes
	4009	+ let dom_elements = this.getDockNode().querySelectorAll('.vbo-admin-dock-element');
	4010	+ this._elements.forEach((element, new_index) => {
	4011	+ let widget_id = element.id;
	4012	+ if (!dom_elements[new_index] || dom_elements[new_index].getAttribute('data-id') != widget_id) {
	4013	+ return;
	4014	+ }
	4015	+ dom_elements[new_index].setAttribute('data-index', new_index);
	4016	+ });
	4017	+ }
	4018	+
	4019	+ if (previousElement && previousElement.id == '_tmp' && typeof previousElement?.details?.persist_id === 'string') {
	4020	+ // we have removed a temporary dock element with persisting data so try to clear the localStorage
	4021	+ VBOCore.storageRemoveItem(this._storageId + '.' + previousElement.details.persist_id);
	4022	+ }
	4023	+
	4024	+ // update dock elements on localStorage
	4025	+ let updated = VBOCore.storageSetItem(this._storageId, this._elements);
	4026	+
	4027	+ return updated;
	4028	+ }
	4029	+
	4030	+ /**
	4031	+ * Removes the first dock element found from the given ID.
	4032	+ *
	4033	+ * @param number id The dock element type ID.
	4034	+ *
	4035	+ * @return bool True if element was found, removed and updated on localStorage.
	4036	+ */
	4037	+ removeDockElementById(id) {
	4038	+ let remove_index = this.getDockElementById(id);
	4039	+
	4040	+ if (remove_index >= 0) {
	4041	+ return this.removeDockElement(remove_index);
	4042	+ }
	4043	+
	4044	+ return false;
	4045	+ }
	4046	+
	4047	+ /**
	4048	+ * Returns the index of the first dock element found from the given ID.
	4049	+ *
	4050	+ * @param string id The dock element type ID.
	4051	+ *
	4052	+ * @return number The index found or -1 if nothing is found.
	4053	+ */
	4054	+ getDockElementById(id) {
	4055	+ let index_found = -1;
	4056	+
	4057	+ this._elements.forEach((element, index) => {
	4058	+ if (index_found >= 0) {
	4059	+ return;
	4060	+ }
	4061	+
	4062	+ if (element.id == id) {
	4063	+ index_found = index;
	4064	+ return;
	4065	+ }
	4066	+ });
	4067	+
	4068	+ return index_found;
	4069	+ }
	4070	+
	4071	+ /**
	4072	+ * Builds a dock element node.
	4073	+ *
	4074	+ * @param object details The element details.
	4075	+ * @param object data The element data.
	4076	+ * @param number index The element index number.
	4077	+ * @param HTMLElement body Optional widget modal body to restore.
	4078	+ * @param function destroyFn Optional dismiss callback.
	4079	+ *
	4080	+ * @return HTMLElement
	4081	+ */
	4082	+ buildDockElement(details, data, index, body, destroyFn) {
	4083	+ if (!details?.id) {
	4084	+ throw new Error('Unknown widget id');
	4085	+ }
	4086	+
	4087	+ const widgetId = details.id;
	4088	+
	4089	+ const element = document.createElement('div');
	4090	+ element.classList.add('vbo-admin-dock-element');
	4091	+ element.setAttribute('data-id', widgetId);
	4092	+ element.setAttribute('data-index', index);
	4093	+ element.setAttribute('data-badge-count', '');
	4094	+
	4095	+ let content = document.createElement('div');
	4096	+ content.classList.add('vbo-admin-dock-element-cont');
	4097	+ content.addEventListener('click', (e) => {
	4098	+ // get content target
	4099	+ let target = e.target;
	4100	+ if (!target.matches('.vbo-admin-dock-element-cont')) {
	4101	+ target = target.closest('.vbo-admin-dock-element-cont');
	4102	+ }
	4103	+
	4104	+ // reset badge count
	4105	+ target.closest('.vbo-admin-dock-element').setAttribute('data-badge-count', '');
	4106	+
	4107	+ // get widget data, if any
	4108	+ let widgetData = data?.event_data?._options || data || {};
	4109	+
	4110	+ // get modal body if NOT from localStorage
	4111	+ let prevBody = target.querySelector('.vbo-admin-dock-element-modalbody');
	4112	+
	4113	+ if (!Object.keys(widgetData).length && prevBody && prevBody.children && prevBody.children[0] && prevBody.children[0]?.children?.length) {
	4114	+ // unset dock-minimized attribute on main element with class "vbo-modal-widget_modal-wrap"
	4115	+ prevBody.children[0].setAttribute('data-dock-minimized', 0);
	4116	+ // get the previous style attribute
	4117	+ let prevBodyStyle = prevBody.children[0].getAttribute('style');
	4118	+
	4119	+ // restore admin widget body previously minimized
	4120	+ let prevTitle = data?.title || '';
	4121	+ let nameSuffix = ' - ' + (details?.name || '');
	4122	+ let modalRestore = {
	4123	+ title: prevTitle + (prevTitle.indexOf(nameSuffix) < 0 ? nameSuffix : ''),
	4124	+ // do not immediately set the restored modal body to prevBody.children[0] in order
	4125	+ // to avoid getting duplicate nested elements with class "vbo-modal-widget_modal-wrap"
	4126	+ // body: prevBody.children[0],
	4127	+ };
	4128	+
	4129	+ if (details?.modal?.add_class && data?.extra_class && (data.extra_class + '').indexOf((details.modal.add_class) + '') < 0) {
	4130	+ // restore widget custom class
	4131	+ modalRestore.extra_class = data.extra_class + ' ' + details.modal.add_class;
	4132	+ }
	4133	+
	4134	+ // add modal restoring class
	4135	+ data.extra_class = ((data.extra_class || '') + ' vbo-restoring').trim();
	4136	+
	4137	+ // display modal with previous content and details to bind
	4138	+ let restoredBody = VBOCore.displayModal(
	4139	+ Object.assign(data, modalRestore),
	4140	+ Object.assign({}, details)
	4141	+ );
	4142	+
	4143	+ if (prevBodyStyle) {
	4144	+ (restoredBody[0] || restoredBody).setAttribute('style', prevBodyStyle);
	4145	+ }
	4146	+
	4147	+ // iterate all children elements of main modal body element with class "vbo-modal-widget_modal-wrap"
	4148	+ // to append and restore the original child nodes and to avoid duplicate container elements
	4149	+ Array.from(prevBody.children[0].children).forEach((child) => {
	4150	+ // append child node to the restored modal body
	4151	+ (restoredBody[0] || restoredBody).append(child);
	4152	+ });
	4153	+
	4154	+ try {
	4155	+ if (typeof data?.onRestore === 'function') {
	4156	+ // call the restoring function from the original modal
	4157	+ data.onRestore.call(restoredBody, e);
	4158	+ }
	4159	+
	4160	+ // always emit the native restoring event for the current widget
	4161	+ VBOCore.emitEvent('vbo-admin-dock-restore-' + widgetId, {
	4162	+ data: data?.event_data || {},
	4163	+ });
	4164	+ } catch(e) {
	4165	+ // do nothing
	4166	+ }
	4167	+ } else {
	4168	+ // re-render admin widget from scratch
	4169	+ VBOCore.handleDisplayWidgetNotification({
	4170	+ widget_id: widgetId,
	4171	+ }, widgetData);
	4172	+ }
	4173	+
	4174	+ // remove element from DOM
	4175	+ let elementIndex = element.getAttribute('data-index');
	4176	+ element.remove();
	4177	+
	4178	+ // remove element index from dock
	4179	+ this.removeDockElement(elementIndex);
	4180	+ });
	4181	+
	4182	+ let content_icon = document.createElement('span');
	4183	+ content_icon.classList.add('vbo-admin-dock-element-icn');
	4184	+ if (details?.style) {
	4185	+ content_icon.classList.add('vbo-admin-widget-style-' + details.style);
	4186	+ }
	4187	+ if (details?.icon) {
	4188	+ content_icon.innerHTML = details.icon;
	4189	+ }
	4190	+
	4191	+ if (body) {
	4192	+ // create hidden node
	4193	+ let modal_body = document.createElement('div');
	4194	+ modal_body.classList.add('vbo-admin-dock-element-modalbody');
	4195	+ modal_body.style.display = 'none';
	4196	+
	4197	+ try {
	4198	+ // move modal body to hidden node
	4199	+ modal_body.append((body[0] || body));
	4200	+
	4201	+ // set dock-minimized attribute
	4202	+ (body[0] || body).setAttribute('data-dock-minimized', 1);
	4203	+
	4204	+ // always dispatch the native minimize event for the current widget
	4205	+ VBOCore.emitEvent('vbo-admin-dock-minimize-' + widgetId, {
	4206	+ data: data?.event_data || {},
	4207	+ });
	4208	+ } catch(e) {
	4209	+ // do nothing
	4210	+ }
	4211	+
	4212	+ // append hidden node to content
	4213	+ content.appendChild(modal_body);
	4214	+ }
	4215	+
	4216	+ let content_name = document.createElement('span');
	4217	+ content_name.classList.add('vbo-admin-dock-element-name');
	4218	+ content_name.innerText = details?.name || '';
	4219	+
	4220	+ let dismiss = document.createElement('span');
	4221	+ dismiss.classList.add('vbo-admin-dock-element-dismiss');
	4222	+ dismiss.innerHTML = '&times;';
	4223	+ dismiss.addEventListener('click', (e) => {
	4224	+ try {
	4225	+ if (typeof destroyFn === 'function') {
	4226	+ // destroy the original modal by firing any dismiss event
	4227	+ destroyFn.call(body, e);
	4228	+ }
	4229	+ } catch(e) {
	4230	+ // do nothing
	4231	+ }
	4232	+
	4233	+ // remove element from DOM
	4234	+ let elementIndex = element.getAttribute('data-index');
	4235	+ element.remove();
	4236	+
	4237	+ // remove element index from dock
	4238	+ this.removeDockElement(elementIndex);
	4239	+ });
	4240	+
	4241	+ // append to content
	4242	+ content.appendChild(content_icon);
	4243	+ content.appendChild(content_name);
	4244	+
	4245	+ // append content to element
	4246	+ element.appendChild(content);
	4247	+
	4248	+ // append dismiss to element
	4249	+ element.appendChild(dismiss);
	4250	+
	4251	+ // return the HTMLElement object
	4252	+ return element;
	4253	+ }
	4254	+
	4255	+ /**
	4256	+ * Builds a temporary dock element node.
	4257	+ *
	4258	+ * @param object details The element details.
	4259	+ * @param object data The element data, usually an array of objects.
	4260	+ * @param number index The element index number.
	4261	+ * @param function restoreFn The callback for restoring the data.
	4262	+ * @param function destroyFn The callback for destroying the data.
	4263	+ * @param number badge Optional badge number to set.
	4264	+ *
	4265	+ * @return HTMLElement
	4266	+ */
	4267	+ buildDockTemporaryElement(details, data, index, restoreFn, destroyFn, badge) {
	4268	+ if (!details?.id || details.id != '_tmp') {
	4269	+ throw new Error('Invalid temporary element data.');
	4270	+ }
	4271	+
	4272	+ const dataId = '_tmp';
	4273	+
	4274	+ const element = document.createElement('div');
	4275	+ element.classList.add('vbo-admin-dock-element');
	4276	+ element.setAttribute('data-id', dataId);
	4277	+ element.setAttribute('data-index', index);
	4278	+ element.setAttribute('data-badge-count', (badge || ''));
	4279	+
	4280	+ let content = document.createElement('div');
	4281	+ content.classList.add('vbo-admin-dock-element-cont');
	4282	+ content.addEventListener('click', (e) => {
	4283	+ // get content target
	4284	+ let target = e.target;
	4285	+ if (!target.matches('.vbo-admin-dock-element-cont')) {
	4286	+ target = target.closest('.vbo-admin-dock-element-cont');
	4287	+ }
	4288	+
	4289	+ // reset badge count
	4290	+ target.closest('.vbo-admin-dock-element').setAttribute('data-badge-count', '');
	4291	+
	4292	+ if (typeof restoreFn === 'function') {
	4293	+ this._elements.forEach((dockEl) => {
	4294	+ if (dockEl.id == dataId) {
	4295	+ // invoke the callback by passing the current element data
	4296	+ restoreFn(dockEl?.data);
	4297	+
	4298	+ // abort
	4299	+ return;
	4300	+ }
	4301	+ });
	4302	+ }
	4303	+
	4304	+ // remove element from DOM
	4305	+ let elementIndex = element.getAttribute('data-index');
	4306	+ element.remove();
	4307	+
	4308	+ // remove element index from dock
	4309	+ this.removeDockElement(elementIndex);
	4310	+ });
	4311	+
	4312	+ let content_icon = document.createElement('span');
	4313	+ content_icon.classList.add('vbo-admin-dock-element-icn');
	4314	+ if (details?.style) {
	4315	+ content_icon.classList.add('vbo-admin-widget-style-' + details.style);
	4316	+ }
	4317	+ if (details?.icon) {
	4318	+ content_icon.innerHTML = details.icon;
	4319	+ }
	4320	+
	4321	+ let content_name = document.createElement('span');
	4322	+ content_name.classList.add('vbo-admin-dock-element-name');
	4323	+ content_name.innerText = details?.name || '';
	4324	+
	4325	+ let dismiss = document.createElement('span');
	4326	+ dismiss.classList.add('vbo-admin-dock-element-dismiss');
	4327	+ dismiss.innerHTML = '&times;';
	4328	+ dismiss.addEventListener('click', (e) => {
	4329	+ if (typeof destroyFn === 'function') {
	4330	+ this._elements.forEach((dockEl) => {
	4331	+ if (dockEl.id == dataId) {
	4332	+ // invoke the callback by passing the current element data
	4333	+ destroyFn(dockEl?.data);
	4334	+
	4335	+ // abort
	4336	+ return;
	4337	+ }
	4338	+ });
	4339	+ }
	4340	+
	4341	+ // remove element from DOM
	4342	+ let elementIndex = element.getAttribute('data-index');
	4343	+ element.remove();
	4344	+
	4345	+ // remove element index from dock
	4346	+ this.removeDockElement(elementIndex);
	4347	+ });
	4348	+
	4349	+ // append to content
	4350	+ content.appendChild(content_icon);
	4351	+ content.appendChild(content_name);
	4352	+
	4353	+ // append content to element
	4354	+ element.appendChild(content);
	4355	+
	4356	+ // append dismiss to element
	4357	+ element.appendChild(dismiss);
	4358	+
	4359	+ // return the HTMLElement object
	4360	+ return element;
	4361	+ }
	4362	+
	4363	+ /**
	4364	+ * Adds a widget to the dock.
	4365	+ *
	4366	+ * @param object details The widget details.
	4367	+ * @param object data The widget restoring data.
	4368	+ * @param HTMLElement body Optional widget modal body to restore.
	4369	+ * @param function destroyFn Optional dismiss callback.
	4370	+ */
	4371	+ addWidget(details, data, body, destroyFn) {
	4372	+ if (!VBOCore.options.widget_ajax_uri) {
	4373	+ throw new Error('Wrong environment');
	4374	+ }
	4375	+
	4376	+ if (typeof details !== 'object') {
	4377	+ details = {};
	4378	+ }
	4379	+
	4380	+ if (!details?.id) {
	4381	+ throw new Error('Unknown widget id');
	4382	+ }
	4383	+
	4384	+ // add element to dock in the DOM at first
	4385	+ this.getDockNode().appendChild(
	4386	+ this.buildDockElement(details, data, this._elements.length, body, destroyFn)
	4387	+ );
	4388	+
	4389	+ // push dock element after it was added to the DOM
	4390	+ this._elements.push({
	4391	+ id: details.id,
	4392	+ details: Object.assign({}, details),
	4393	+ data: Object.assign({}, (data?.event_data?._options || {})),
	4394	+ });
	4395	+
	4396	+ // ensure dock is visible
	4397	+ this.showDock();
	4398	+
	4399	+ // update dock elements on localStorage at last
	4400	+ VBOCore.storageSetItem(this._storageId, this._elements);
	4401	+ }
	4402	+
	4403	+ /**
	4404	+ * Adds temporary data to the dock. Data will NOT persist on the same localStorage key.
	4405	+ * Originally introduced to handle the rates update requests within a queue.
	4406	+ *
	4407	+ * @param object details The data details.
	4408	+ * @param object data The data to store, usually an array of objects.
	4409	+ * @param function restoreFn The callback for restoring the data.
	4410	+ * @param function destroyFn The callback for destroying the data.
	4411	+ * @param number badge Optional badge number to set.
	4412	+ */
	4413	+ addTemporaryData(details, data, restoreFn, destroyFn, badge) {
	4414	+ if (!VBOCore.options.widget_ajax_uri) {
	4415	+ throw new Error('Wrong environment');
	4416	+ }
	4417	+
	4418	+ if (typeof details !== 'object') {
	4419	+ details = {};
	4420	+ }
	4421	+
	4422	+ // temporary data will always get a private ID to avoid duplicate entries in the dock
	4423	+ details.id = '_tmp';
	4424	+
	4425	+ // check if the same temporary data element type exists
	4426	+ let previousElement = null;
	4427	+ let previousIndex = null;
	4428	+ this.getElements().forEach((element, index) => {
	4429	+ if (previousElement) {
	4430	+ return;
	4431	+ }
	4432	+ if (element.id == details.id) {
	4433	+ // previous temporary data element type found
	4434	+ previousElement = element;
	4435	+ previousIndex = index;
	4436	+ return;
	4437	+ }
	4438	+ });
	4439	+
	4440	+ if (!previousElement) {
	4441	+ // add temporary element to dock in the DOM at first
	4442	+ this.getDockNode().appendChild(
	4443	+ this.buildDockTemporaryElement(details, data, this._elements.length, restoreFn, destroyFn, (badge ? badge : (Array.isArray(data) ? data.length : null)))
	4444	+ );
	4445	+
	4446	+ // push dock element after it was added to the DOM
	4447	+ this._elements.push({
	4448	+ id: details.id,
	4449	+ details: Object.assign({}, details),
	4450	+ data: Array.isArray(data) ? [...data] : Object.assign({}, data),
	4451	+ });
	4452	+ } else {
	4453	+ // update previous temporary data element type
	4454	+ let updatedData = Array.isArray(data) && Array.isArray(previousElement.data) ? [...previousElement.data].concat([...data]) : [...data];
	4455	+ let updatedBadge = badge ? badge : (Array.isArray(updatedData) ? updatedData.length : previousElement.badge);
	4456	+
	4457	+ // update existing dock element
	4458	+ this._elements[previousIndex] = {
	4459	+ id: details.id,
	4460	+ details: Object.assign({}, previousElement.details, details),
	4461	+ data: updatedData,
	4462	+ };
	4463	+
	4464	+ if (updatedBadge) {
	4465	+ // update DOM element
	4466	+ let dom_elements = this.getDockNode().querySelectorAll('.vbo-admin-dock-element');
	4467	+ this._elements.forEach((element, cur_index) => {
	4468	+ if (!dom_elements[cur_index] || dom_elements[cur_index].getAttribute('data-id') != element.id) {
	4469	+ return;
	4470	+ }
	4471	+ if (dom_elements[cur_index].getAttribute('data-id') != details.id) {
	4472	+ return;
	4473	+ }
	4474	+ // update badge attribute
	4475	+ dom_elements[cur_index].setAttribute('data-badge-count', updatedBadge);
	4476	+ });
	4477	+ }
	4478	+ }
	4479	+
	4480	+ // ensure dock is visible
	4481	+ this.showDock();
	4482	+
	4483	+ if (details.persist_id && typeof details.persist_id === 'string') {
	4484	+ // update dock element on a different localStorage key at last
	4485	+ VBOCore.storageSetItem(this._storageId + '.' + details.persist_id, (previousIndex ? this._elements[previousIndex] : this._elements[this._elements.length - 1]));
	4486	+ }
	4487	+ }
	4488	+
	4489	+ /**
	4490	+ * Loads temporary data onto the dock by using an ID and type identifier.
	4491	+ * Originally introduced to handle the rates update requests within a queue.
	4492	+ *
	4493	+ * @param object details The data details to load.
	4494	+ * @param function restoreFn The callback for restoring the data.
	4495	+ * @param function destroyFn The callback for destroying the data.
	4496	+ * @param number badge Optional badge number to set.
	4497	+ *
	4498	+ * @return any Data object loaded on success or null.
	4499	+ */
	4500	+ loadTemporaryData(details, restoreFn, destroyFn, badge) {
	4501	+ if (!VBOCore.options.widget_ajax_uri) {
	4502	+ throw new Error('Wrong environment');
	4503	+ }
	4504	+
	4505	+ if (typeof details !== 'object' || !details.id || !details.persist_id || typeof details.persist_id !== 'string') {
	4506	+ return null;
	4507	+ }
	4508	+
	4509	+ // temporary data will always get a private ID to avoid duplicate entries in the dock
	4510	+ details.id = '_tmp';
	4511	+
	4512	+ // check if the same temporary data element type exists
	4513	+ let previousElement = null;
	4514	+ this.getElements().forEach((element, index) => {
	4515	+ if (previousElement) {
	4516	+ return;
	4517	+ }
	4518	+ if (element.id == details.id) {
	4519	+ // previous temporary data element type found
	4520	+ previousElement = element;
	4521	+ return;
	4522	+ }
	4523	+ });
	4524	+
	4525	+ if (previousElement) {
	4526	+ // temporary data already loaded in dock
	4527	+ return previousElement;
	4528	+ }
	4529	+
	4530	+ // load the requested temporary and persisting data
	4531	+ let storageElement = VBOCore.storageGetItem(this._storageId + '.' + details.persist_id);
	4532	+
	4533	+ try {
	4534	+ if (typeof storageElement === 'string') {
	4535	+ storageElement = JSON.parse(storageElement);
	4536	+ }
	4537	+ } catch(e) {
	4538	+ storageElement = null;
	4539	+ }
	4540	+
	4541	+ if (!storageElement || typeof storageElement !== 'object' || !storageElement.data) {
	4542	+ return null;
	4543	+ }
	4544	+
	4545	+ // add the temporary data just loaded to the dock
	4546	+ this.addTemporaryData(Object.assign({}, (storageElement.details || {}), details), storageElement.data, restoreFn, destroyFn, badge);
	4547	+
	4548	+ // return the data loaded
	4549	+ return storageElement;
	4550	+ }
	4551	+
	4552	+ /**
	4553	+ * Returns the current dock elements.
	4554	+ *
	4555	+ * @return Array
	4556	+ */
	4557	+ getElements() {
	4558	+ return this._elements;
	4559	+ }
	4560	+
	4561	+ /**
	4562	+ * Loads widget dock elements from localStorage and populates them, if any.
	4563	+ */
	4564	+ loadDockElements() {
	4565	+ let storageElements = VBOCore.storageGetItem(this._storageId) || [];
	4566	+
	4567	+ try {
	4568	+ if (typeof storageElements === 'string') {
	4569	+ storageElements = JSON.parse(storageElements);
	4570	+ }
	4571	+ } catch(e) {
	4572	+ storageElements = [];
	4573	+ }
	4574	+
	4575	+ if (Array.isArray(storageElements)) {
	4576	+ // set current elements
	4577	+ this._elements = storageElements;
	4578	+ }
	4579	+
	4580	+ // scan all elements to ensure no temporary data was stored upon deleting or adding new widgets
	4581	+ this._elements.forEach((element, index) => {
	4582	+ if (element?.id == '_tmp') {
	4583	+ // splice the elements list
	4584	+ this._elements.splice(index, 1);
	4585	+
	4586	+ // update dock elements on localStorage by only keeping real widgets
	4587	+ VBOCore.storageSetItem(this._storageId, this._elements);
	4588	+
	4589	+ // abort
	4590	+ return;
	4591	+ }
	4592	+ });
	4593	+
	4594	+ if (this._elements.length) {
	4595	+ // populate dock elements
	4596	+ this.populateDockElements();
	4597	+
	4598	+ // show the dock
	4599	+ this.showDock();
	4600	+ } else {
	4601	+ // hide the dock
	4602	+ this.hideDock();
	4603	+ }
	4604	+ }
	4605	+
	4606	+ /**
	4607	+ * Populates the current dock elements.
	4608	+ */
	4609	+ populateDockElements() {
	4610	+ const dockNode = this.getDockNode();
	4611	+
	4612	+ // empty the dock
	4613	+ dockNode.innerHTML = '';
	4614	+
	4615	+ // scan all elements
	4616	+ this._elements.forEach((element, index) => {
	4617	+ // add element to dock in the DOM at first
	4618	+ dockNode.appendChild(
	4619	+ this.buildDockElement(element?.details, element?.data, index)
	4620	+ );
	4621	+ });
	4622	+ }
	4623	+
	4624	+ /**
	4625	+ * Hides the dock node.
	4626	+ */
	4627	+ hideDock() {
	4628	+ this.getDockNode().style.display = 'none';
	4629	+ }
	4630	+
	4631	+ /**
	4632	+ * Shows the dock node.
	4633	+ */
	4634	+ showDock() {
	4635	+ if (!this.getDockNode().checkVisibility()) {
	4636	+ this.getDockNode().style.display = this._options.dockDisplayStyle;
	4637	+ }
	4638	+ }
	4639	+
	4640	+ /**
	4641	+ * Event callback fired to update the element(s) badge counter.
	4642	+ */
	4643	+ updateElementsBadgeCounter(e) {
	4644	+ if (!e || !e.detail || !e.detail?.widgetId) {
	4645	+ return;
	4646	+ }
	4647	+
	4648	+ let elements = VBOAdminDock.getInstance().getElements();
	4649	+
	4650	+ if (!elements.length) {
	4651	+ return;
	4652	+ }
	4653	+
	4654	+ let widgetId = e.detail.widgetId;
	4655	+ let badgeCount = parseInt(e.detail?.badgeCount || 0);
	4656	+ let badgeValue = badgeCount > 0 ? badgeCount : '';
	4657	+
	4658	+ elements.forEach((element) => {
	4659	+ if (element.id == widgetId) {
	4660	+ document.querySelectorAll('.vbo-admin-dock-element[data-id="' + widgetId + '"]').forEach((elNode) => {
	4661	+ elNode.setAttribute('data-badge-count', badgeValue);
	4662	+ });
	4663	+ }
	4664	+ });
	4665	+ }
	4666	+ }
	4667	+
	4668	+})(jQuery, window);