@cortezaproject/corteza-vue 2021.9.9 → 2021.9.12

package/dist/components/c3/C3.d.ts

@@ -0,0 +1,5 @@
+declare namespace _default {
+    export { itemPicker };
+}
+export default _default;
+import * as itemPicker from "../itemPicker/C3";

package/dist/components/input/CInputDateTime/lib/index.d.ts

@@ -0,0 +1,4 @@
+export declare function getDate(value: string | undefined): string | undefined;
+export declare function getTime(value: string | undefined): string | undefined;
+export declare function setDate(date: string | undefined, value: string | undefined, noDate?: boolean, noTime?: boolean): string | undefined;
+export declare function setTime(time: string | undefined, value: string | undefined, noDate?: boolean, noTime?: boolean): string | undefined;

package/dist/components/itemPicker/C3.d.ts

@@ -0,0 +1 @@
+export { default as CItemPicker } from "./CItemPicker.c3";

package/dist/components/itemPicker/CItemPicker.c3.d.ts

@@ -0,0 +1,32 @@
+/// <reference path="../../src/vue.shims.d.ts" />
+declare namespace _default {
+    export const name: string;
+    export const group: string[];
+    export { component };
+    export { props };
+    export const controls: any[];
+}
+export default _default;
+import { default as component } from "*.vue";
+declare namespace props {
+    export const options: {
+        value: string;
+        text: string;
+    }[];
+    export const value: string[];
+    export namespace labels {
+        export const searchPlaceholder: string;
+        export const availableItems: string;
+        export const selectAllItems: string;
+        export const selectedItems: string;
+        export const systemItem: string;
+        export const unselectAllItems: string;
+        export const noItemsFound: string;
+    }
+    export const hideFilter: boolean;
+    export const hideIcons: boolean;
+    export const disabled: boolean;
+    export const disabledFilter: boolean;
+    export const disabledSorting: boolean;
+    export const disabledDragging: boolean;
+}

package/dist/components/itemPicker/index.d.ts

@@ -0,0 +1,2 @@
+export { default as CItemPicker } from './CItemPicker.vue';
+export { default as CItemPickerItem } from './CItemPickerItem.vue';

package/dist/components/reporter/index.d.ts

@@ -0,0 +1,4 @@
+export { default as CReportChart } from './Viewers/CReportChart.vue';
+export { default as CReportMetric } from './Viewers/CReportMetric.vue';
+export { default as CReportTable } from './Viewers/CReportTable.vue';
+export { default as CReportText } from './Viewers/CReportText.vue';

package/dist/index.es.js

@@ -1934,7 +1934,7 @@ const storeKeyFinalState = 'auth.state.final';
 const storeKeyRefreshToken = 'auth.refresh-token';
 const maxStartAttempts = 5;
 class Auth {
-    constructor({ app, verbose, cortezaAuthURL, callbackURL, entrypointURL, location, sessionStorage, refreshFactor }) {
+    constructor({ app, verbose, cortezaAuthURL, callbackURL, entrypointURL, location, sessionStorage, refreshFactor, registerEventListener }) {
         if (refreshFactor >= 1 || refreshFactor <= 0) {
             throw new Error('refreshFactor should be between 0 and 1');
         }
@@ -1944,6 +1944,7 @@ class Auth {
         this.callbackURL = callbackURL;
         this.location = location;
         this.sessionStorage = sessionStorage;
+        this.registerEventListener = registerEventListener;
         this.refreshFactor = refreshFactor;
         this.entrypointURL = entrypointURL;
         this.log.debug('initialized auth plugin', {
@@ -1998,38 +1999,26 @@ class Auth {
     handle(req = new URL(this.entrypointURL)) {
         return __awaiter(this, void 0, void 0, function* () {
             this.log.info('handling authentication');
-            if (this.isCallback(req.pathname)) {
-                this.log.info('handling authentication callback');
-                const params = new URLSearchParams(req.search);
+            // State management
+            // - duplication checking
+            // - management handlers
+            const dup = this.handleStateManagement();
+            if (dup) {
+                this.log.debug('duplicate tab: unauthorized');
+                throw new Error('Unauthenticated');
+            }
+            // Handle auth callback requests
+            const params = new URLSearchParams(req.search);
+            if (this.isCallback(req.pathname) && (params.has('error') || params.has('code'))) {
                 if (params.has('error')) {
                     throw new Error(params.get('error') || 'authentication flow failed with error');
                 }
-                if (params.has('code')) {
-                    let finalLocation = this.entrypointURL;
-                    if (params.has('state')) {
-                        const state = params.get('state') || '';
-                        const storeKeyStateLocation = `auth.state.${state}.location`;
-                        const tmp = this.sessionStorage.getItem(storeKeyStateLocation);
-                        if (tmp === null) {
-                            console.warn('state does not match, restarting authentication flow');
-                            this.startAuthenticationFlow();
-                            return null;
-                        }
-                        if (!this.isCallback(tmp)) {
-                            // if by some coincidence we got callback URL to finalLocation
-                            // we'll silently ignore it and redirect user back to entrypoint
-                            finalLocation = tmp;
-                        }
-                        this.sessionStorage.removeItem(storeKeyStateLocation);
-                    }
-                    const code = params.get('code') || '';
-                    this.log.info('authorization code received', code);
-                    const rsp = yield this.exchangeCode(code);
-                    this.startFinalState(finalLocation);
-                    return rsp;
-                }
+                this.log.info('handling authentication callback');
+                return this.handleCallbackRoute(params.get('state'), (params.has('code') ? params.get('code') : ''));
             }
-            return this.check();
+            // Handle auth from the current system state
+            this.log.info('handling authentication from state');
+            return this.handleState();
         });
     }
     /**
@@ -2046,10 +2035,16 @@ class Auth {
      * know, after the redirection to the final location, if this is a final stage or not and if the refresh token
      * belongs to this session or not.
      */
-    startFinalState(dst) {
-        this.log.info('redirecting back to final destination', dst);
+    handleStateManagement() {
+        // See if this is a duplicate
+        const dup = this.sessionStorage.getItem(storeKeyFinalState) !== null;
+        // Bind listeners to cleanup
+        this.registerEventListener('beforeunload', function () {
+            this.sessionStorage.removeItem(storeKeyFinalState);
+        });
+        // Set state
         this.sessionStorage.setItem(storeKeyFinalState, Date.now().toString());
-        this.location.assign(dst);
+        return dup;
     }
     /**
      * Called when refresh token is re-fetched.
@@ -2057,7 +2052,6 @@ class Auth {
      * Cleanup aux items in the session store
      */
     completeFinalState() {
-        this.sessionStorage.removeItem(storeKeyFinalState);
         this.sessionStorage.removeItem(storeKeyFlowStarted);
         const stateKey = /^auth\.state\.\w+\.location$/;
         for (let i = 0; i < this.sessionStorage.length; i++) {
@@ -2068,12 +2062,38 @@ class Auth {
         }
     }
     /**
-     * Are we in a final state or not?
+     * Exchanges the auth parameters for access & refresh token.
+     *
+     * If the parameters are correct and exchange is successful, the refresh token
+     * gets stored in localStorage for further use, the access token and current user get stored
+     * in-memory.
      *
-     * See startFinalState function for more details
+     * Function will throw null when user is unauthenticated
      */
-    inFinalState() {
-        return this.sessionStorage.getItem(storeKeyFinalState) !== null;
+    handleCallbackRoute(state, code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let finalLocation = this.entrypointURL;
+            if (state) {
+                const storeKeyStateLocation = `auth.state.${state}.location`;
+                const tmp = this.sessionStorage.getItem(storeKeyStateLocation);
+                if (tmp === null) {
+                    console.warn('state does not match, restarting authentication flow');
+                    this.startAuthenticationFlow();
+                    return null;
+                }
+                if (!this.isCallback(tmp)) {
+                    // if by some coincidence we got callback URL to finalLocation
+                    // we'll silently ignore it and redirect user back to entrypoint
+                    finalLocation = tmp;
+                }
+                this.sessionStorage.removeItem(storeKeyStateLocation);
+            }
+            this.log.info('authorization code received', code);
+            const rsp = yield this.exchangeCode(code);
+            this.log.info('redirecting back to final destination', finalLocation);
+            this.location.assign(finalLocation);
+            return rsp;
+        });
     }
     /**
      * Checks current auth state; is access token loaded OR do we have a refresh token we can use
@@ -2087,7 +2107,7 @@ class Auth {
      *
      * Function will throw null when user is unauthenticated
      */
-    check() {
+    handleState() {
         return __awaiter(this, void 0, void 0, function* () {
             this.log.info('checking authentication');
             if (this[accessToken]) {
@@ -2123,14 +2143,12 @@ class Auth {
                  * If this is a duplicated-session, an error will be thrown and authentication will be (probably)
                  * restarted by the caller.
                  */
-                if (this.inFinalState()) {
-                    this.log.info('refreshing token', refreshToken);
-                    /**
-                     * Refresh token found in the storage,
-                     * let's use it to get new access token
-                     */
-                    return this.exchangeRefresh(refreshToken);
-                }
+                this.log.info('refreshing token', refreshToken);
+                /**
+                 * Refresh token found in the storage,
+                 * let's use it to get new access token
+                 */
+                return this.exchangeRefresh(refreshToken);
             }
             throw new Error('Unauthenticated');
         });
@@ -2321,7 +2339,7 @@ class Auth {
 }
 function auth () {
     return function (Vue, opts) {
-        let { app = '', rootApp = false, cortezaAuthURL = '', callbackURL = '', verbose = undefined, refreshFactor = 0.75, entrypointURL = window.location.toString(), location = window.location, sessionStorage = window.sessionStorage, } = (opts || {});
+        let { app = '', rootApp = false, cortezaAuthURL = '', callbackURL = '', verbose = undefined, refreshFactor = 0.75, entrypointURL = window.location.toString(), location = window.location, sessionStorage = window.sessionStorage, registerEventListener = window.addEventListener.bind(window), } = (opts || {});
         if (!cortezaAuthURL) {
             /**
              * cortezaAuthURL not explicitly set, try to auto-configure from properties set on window variable
@@ -2415,6 +2433,7 @@ function auth () {
             sessionStorage,
             entrypointURL,
             refreshFactor,
+            registerEventListener,
         });
     };
 }
@@ -80405,7 +80424,16 @@ var script$y = {
 
   data() {
     return {
-      passive: new Set()
+      passive: new Set(),
+
+      /**
+       * Set initial value to NULL
+       *
+       * First interval will detect that null is not true|false
+       * and set it accordingly to the current state
+       */
+      hasFocus: null,
+      hasFocusObserver: 0
     };
   },
 
@@ -80415,16 +80443,30 @@ var script$y = {
       isLoading: 'wfPrompts/isLoading'
     }),
 
+    /**
+     * Prompts with handlers, observed with "watch"
+     *
+     * Prompts are only returned when document has focus!
+     *
+     * @returns {*}
+     */
     withHandlers() {
-      return this.prompts.filter(({
+      return (this.hasFocus ? this.prompts : []).filter(({
         ref
       }) => !!definitions[ref] && !!definitions[ref].handler).map(prompt => ({ ...definitions[prompt.ref],
         prompt
       }));
     },
 
+    /**
+     * Prompts with components
+     *
+     * Prompts are only returned when document has focus!
+     *
+     * @returns {*}
+     */
     withComponents() {
-      return this.prompts.filter(({
+      return (this.hasFocus ? this.prompts : []).filter(({
         ref
       }) => !!definitions[ref] && !!definitions[ref].component).map(prompt => ({ ...definitions[prompt.ref],
         prompt
@@ -80479,11 +80521,11 @@ var script$y = {
      * We do this because we do not want it to be removed right away
      * but through a toast component's timeout
      */
-    prompts: {
+    withComponents: {
       immediate: true,
 
-      handler() {
-        this.withComponents.forEach(p => {
+      handler(wc) {
+        wc.forEach(p => {
           if (p.passive) {
             this.passive.add(p);
           }
@@ -80508,9 +80550,38 @@ var script$y = {
 
     pVal(prompt, k, def = undefined) {
       return pVal(prompt.payload, k, def);
+    },
+
+    clearDocumentFocusObserver() {
+      if (this.hasFocusObserver) {
+        window.clearInterval(this.hasFocusObserver);
+      }
+    },
+
+    /**
+     * Interval check if window has focus
+     */
+    setDocumentFocusObserver() {
+      this.clearDocumentFocusObserver();
+      this.hasFocusObserver = window.setInterval(() => {
+        const f = document.hasFocus();
+
+        if (this.hasFocus !== f) {
+          this.hasFocus = f;
+        }
+      }, 250);
     }
 
+  },
+
+  mounted() {
+    this.setDocumentFocusObserver();
+  },
+
+  beforeDestroy() {
+    this.clearDocumentFocusObserver();
   }
+
 };
 
 /* script */
@@ -80527,11 +80598,11 @@ var __vue_staticRenderFns__$t = [];
   /* style */
   const __vue_inject_styles__$z = function (inject) {
     if (!inject) return
-    inject("data-v-6aed55b2_0", { source: ".slide-enter-active[data-v-6aed55b2]{transition:all .3s ease}.slide-leave-active[data-v-6aed55b2]{transition:all .8s cubic-bezier(1,.5,.8,1)}.slide-enter[data-v-6aed55b2],.slide-leave-to[data-v-6aed55b2]{transform:translateX(10px);opacity:0}", map: undefined, media: undefined });
+    inject("data-v-e3fcdf3e_0", { source: ".slide-enter-active[data-v-e3fcdf3e]{transition:all .3s ease}.slide-leave-active[data-v-e3fcdf3e]{transition:all .8s cubic-bezier(1,.5,.8,1)}.slide-enter[data-v-e3fcdf3e],.slide-leave-to[data-v-e3fcdf3e]{transform:translateX(10px);opacity:0}", map: undefined, media: undefined });
 
   };
   /* scoped */
-  const __vue_scope_id__$z = "data-v-6aed55b2";
+  const __vue_scope_id__$z = "data-v-e3fcdf3e";
   /* module identifier */
   const __vue_module_identifier__$z = undefined;
   /* functional template */
@@ -100597,10 +100668,6 @@ function index$6 ({ api }) {
                     commit('active', false);
                 });
             },
-            // unwatch ({ state, commit }: ActionContext<State, State>): void {
-            //   commit('watching', undefined)
-            //   clearInterval(state.wiptr)
-            // },
             // fetch calls automation API endpoint and collects all states
             update({ commit, state }) {
                 return __awaiter(this, void 0, void 0, function* () {
@@ -100654,9 +100721,6 @@ function index$6 ({ api }) {
             loading(state, flag = true) {
                 state.loading = flag;
             },
-            // watching (state: State, ptr?: number): void {
-            //   state.wiptr = ptr
-            // },
             active(state, m) {
                 state.active = m;
             },