libshv-js 3.16.1 → 3.20.0

package/{src/vue-shv.ts → dist/vue-shv.js}

@@ -1,36 +1,48 @@
-import {computed, ComputedRef, Ref, ref, watchEffect} from 'vue';
-import {WsClient, WsClientOptionsLogin} from './ws-client';
-import {useLocalStorage, useSessionStorage} from '@vueuse/core';
-import PKCE from 'js-pkce';
-import * as z from './zod';
-import {RpcValue} from './rpcvalue';
-
-type GlobalResourceOptions<ResourceType> = {
-    shvPath: string;
-    method: string;
-    validator: z.ZodType<ResourceType>;
-    signalName: string;
-    signalHandler: (param: RpcValue, resource: Ref<ResourceType | undefined>, reinit: () => void) => void;
-};
-
-type VueShvOptions = {
-    wsUri: string;
-    onRequest: WsClientOptionsLogin['onRequest'];
-    azureCodeRedirect?: string;
-};
-
-type ShvLocalStorage = {
-    azureAccessToken?: string;
-    azureRedirectTo?: string;
-};
-
-type ShvSessionStorage = {
-    shvLoginUser?: string;
-    shvLoginPassword?: string;
-
-    azureWorkflow?: z.infer<typeof OAuth2AzureWorkflowZod>;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fullReloadHandler = exports.azure = exports.LoginFailureReason = void 0;
+exports.useShv = useShv;
+const vue_1 = require("vue");
+const ws_client_1 = require("./ws-client");
+const core_1 = require("@vueuse/core");
+const js_pkce_1 = __importDefault(require("js-pkce"));
+const z = __importStar(require("./zod"));
 const OAuth2AzureWorkflowZod = z.map({
     type: z.literal('oauth2-azure'),
     authorizeUrl: z.string(),
@@ -38,22 +50,16 @@ const OAuth2AzureWorkflowZod = z.map({
     clientId: z.string(),
     scopes: z.string().or(z.array(z.string())),
 });
-
-export enum LoginFailureReason {
-    NoCredentials,
-    AzureTimedOut,
-    AzureUnsupported,
-    CouldntLogin,
-    LoggedOut,
-}
-
-type LoginFailure = {
-    reason: LoginFailureReason;
-    message?: string;
-};
-
-const makePkce = (oauthOptions: {azureCodeRedirect: string, clientId: string; authorizeUrl: string; tokenUrl: string; scopes: string | string[]}) => {
-    const pkce = new PKCE({
+var LoginFailureReason;
+(function (LoginFailureReason) {
+    LoginFailureReason[LoginFailureReason["NoCredentials"] = 0] = "NoCredentials";
+    LoginFailureReason[LoginFailureReason["AzureTimedOut"] = 1] = "AzureTimedOut";
+    LoginFailureReason[LoginFailureReason["AzureUnsupported"] = 2] = "AzureUnsupported";
+    LoginFailureReason[LoginFailureReason["CouldntLogin"] = 3] = "CouldntLogin";
+    LoginFailureReason[LoginFailureReason["LoggedOut"] = 4] = "LoggedOut";
+})(LoginFailureReason || (exports.LoginFailureReason = LoginFailureReason = {}));
+const makePkce = (oauthOptions) => {
+    const pkce = new js_pkce_1.default({
         client_id: oauthOptions.clientId,
         redirect_uri: (() => {
             const url = new URL(globalThis.location.href);
@@ -67,65 +73,49 @@ const makePkce = (oauthOptions: {azureCodeRedirect: string, clientId: string; au
     });
     return pkce;
 };
-
-export {makePkce as azure};
-
-export function useShv(options: VueShvOptions) {
-    const shvLocalStorage = useLocalStorage<ShvLocalStorage>('vue-shv', {});
-    const shvSessionStorage = useSessionStorage<ShvSessionStorage>('vue-shv', {});
-
-    const displayName = ref('Loading...');
-    const displayShortName = ref('');
-    const displayFullName = ref('');
-    const displayEmail = ref('');
-    const displayPhoto = ref<string>();
-
+exports.azure = makePkce;
+function useShv(options) {
+    const shvLocalStorage = (0, core_1.useLocalStorage)('vue-shv', {});
+    const shvSessionStorage = (0, core_1.useSessionStorage)('vue-shv', {});
+    const displayName = (0, vue_1.ref)('Loading...');
+    const displayShortName = (0, vue_1.ref)('');
+    const displayFullName = (0, vue_1.ref)('');
+    const displayEmail = (0, vue_1.ref)('');
+    const displayPhoto = (0, vue_1.ref)();
     const state = {
-        ws: undefined as WsClient | undefined,
-        reconnectService: undefined as ReturnType<typeof globalThis.setTimeout> | undefined,
+        ws: undefined,
+        reconnectService: undefined,
     };
-
-    const waitingForSocket: Array<{
-        resolve: (value: WsClient) => void;
-        reject: () => void;
-    }> = [];
-
+    const waitingForSocket = [];
     const resetAzureToken = () => {
         shvLocalStorage.value.azureAccessToken = undefined;
     };
-
     const azureAvailable = async () => {
         const accessToken = shvLocalStorage.value.azureAccessToken;
         if (accessToken === undefined) {
             return LoginFailureReason.NoCredentials;
         }
-
         const resp = await fetch('https://graph.microsoft.com/v1.0/me', {
             headers: {
                 Authorization: `Bearer ${accessToken}`,
             },
         });
-
-        const json = await resp.json() as unknown;
-
+        const json = await resp.json();
         if (typeof json === 'object' && json !== null) {
             if ('displayName' in json && typeof json.displayName === 'string') {
                 displayName.value = json.displayName;
             }
-
             if ('givenName' in json && typeof json.givenName === 'string'
                 && 'surname' in json && typeof json.surname === 'string') {
-                const firstName: string = json.givenName;
-                const lastname: string = json.surname;
+                const firstName = json.givenName;
+                const lastname = json.surname;
                 displayShortName.value = firstName.charAt(0) + lastname.charAt(0);
                 displayFullName.value = firstName + ' ' + lastname;
             }
-
             if ('mail' in json && typeof json.mail === 'string') {
                 displayEmail.value = json.mail;
             }
         }
-
         const photo = await fetch('https://graph.microsoft.com/v1.0/me/photos/48x48/$value', {
             headers: {
                 Authorization: `Bearer ${accessToken}`,
@@ -134,26 +124,20 @@ export function useShv(options: VueShvOptions) {
         if (photo.ok) {
             displayPhoto.value = URL.createObjectURL(await photo.blob());
         }
-
         if (!resp.ok) {
             resetAzureToken();
         }
-
         return resp.ok ? 'azureAvailable' : LoginFailureReason.AzureTimedOut;
     };
-
-    const debug = (...args: string[]) => {
+    const debug = (...args) => {
         logContents.value = logContents.value + args.join(' ') + '\n';
         console.debug(...args);
     };
-
-    const azureAuth = (redirectTo?: string) => {
+    const azureAuth = (redirectTo) => {
         if (options.azureCodeRedirect === undefined) {
             throw new Error('Azure redirect URL not set');
         }
-
-        const {azureCodeRedirect} = options;
-
+        const { azureCodeRedirect } = options;
         shvLocalStorage.value.azureRedirectTo = redirectTo ?? globalThis.location.pathname;
         const noBrokerSupport = () => {
             loginFailure.value = {
@@ -161,8 +145,7 @@ export function useShv(options: VueShvOptions) {
                 message: 'Broker does not support Azure',
             };
         };
-
-        state.ws = new WsClient({
+        state.ws = new ws_client_1.WsClient({
             logDebug: debug,
             wsUri: options.wsUri,
             onWorkflows(workflows) {
@@ -170,16 +153,13 @@ export function useShv(options: VueShvOptions) {
                     noBrokerSupport();
                     return;
                 }
-
                 for (const workflow of workflows) {
                     const parsedWorkflow = OAuth2AzureWorkflowZod.safeParse(workflow);
                     if (!parsedWorkflow.success) {
                         continue;
                     }
-
                     shvSessionStorage.value.azureWorkflow = parsedWorkflow.data;
-
-                    globalThis.location.replace(makePkce({...parsedWorkflow.data, azureCodeRedirect}).authorizeUrl());
+                    globalThis.location.replace(makePkce({ ...parsedWorkflow.data, azureCodeRedirect }).authorizeUrl());
                 }
             },
             onWorkflowsFailed() {
@@ -187,57 +167,46 @@ export function useShv(options: VueShvOptions) {
             },
         });
     };
-
-    const setShvCredentials = (userName: string, password: string) => {
+    const setShvCredentials = (userName, password) => {
         shvLogout();
         shvSessionStorage.value.shvLoginUser = userName;
         shvSessionStorage.value.shvLoginPassword = password;
     };
-
-    const rpcCall = async (shvPath: string, method: string, params?: RpcValue) => {
+    const rpcCall = async (shvPath, method, params) => {
         const shv = await getConnection();
         return shv.callRpcMethod(shvPath, method, params);
     };
-
-    const makeRpcCall = <ResultType>(shvPath: string, method: string, validator: z.ZodType<ResultType>) => async () => {
+    const makeRpcCall = (shvPath, method, validator) => async () => {
         const resultOrError = await rpcCall(shvPath, method);
         if (resultOrError instanceof Error) {
             return resultOrError;
         }
-
         const parsed = validator.safeParse(resultOrError);
         if (!parsed.success) {
             return new Error(parsed.error.message);
         }
-
         return parsed.data;
     };
-
-    const makeRpcCallParam = <ResultType, ParamType extends RpcValue>(shvPath: string, method: string, _paramType: z.ZodType<ParamType>, validator: z.ZodType<ResultType>) => async (param: ParamType) => {
+    const makeRpcCallParam = (shvPath, method, _paramType, validator) => async (param) => {
         const resultOrError = await rpcCall(shvPath, method, param);
         if (resultOrError instanceof Error) {
             return resultOrError;
         }
-
         const parsed = validator.safeParse(resultOrError);
         if (!parsed.success) {
             return new Error(parsed.error.message);
         }
-
         return parsed.data;
     };
-
-    const connected = ref<'connected' | 'connecting' | 'disconnected'>('disconnected');
-    const logContents = ref('');
+    const connected = (0, vue_1.ref)('disconnected');
+    const logContents = (0, vue_1.ref)('');
     const shvLogout = () => {
         resetAzureToken();
         shvSessionStorage.value.shvLoginUser = undefined;
         shvSessionStorage.value.shvLoginPassword = undefined;
-
         for (const waiter of waitingForSocket) {
             waiter.reject();
         }
-
         connected.value = 'disconnected';
         waitingForSocket.length = 0;
         state.ws?.close();
@@ -245,23 +214,19 @@ export function useShv(options: VueShvOptions) {
         displayPhoto.value = undefined;
         state.ws = undefined;
     };
-
-    const loginFailure = ref<LoginFailure>();
-
+    const loginFailure = (0, vue_1.ref)();
     const getConnection = async () => {
         if (connected.value === 'connected') {
-            return state.ws!;
+            return state.ws;
         }
-
-        return new Promise<WsClient>((resolve, reject) => {
-            waitingForSocket.push({resolve, reject});
+        return new Promise((resolve, reject) => {
+            waitingForSocket.push({ resolve, reject });
             if (connected.value === 'connecting') {
                 // We should try to connect only once at the same time.
                 return;
             }
-
             connected.value = 'connecting';
-            const doConnect = (user: string, password: string, loginType: 'PLAIN' | 'TOKEN') => {
+            const doConnect = (user, password, loginType) => {
                 console.log('Connecting to', options.wsUri);
                 const makeLoginOptions = () => {
                     switch (loginType) {
@@ -278,17 +243,15 @@ export function useShv(options: VueShvOptions) {
                             };
                     }
                 };
-
-                state.ws = new WsClient({
+                state.ws = new ws_client_1.WsClient({
                     login: makeLoginOptions(),
                     wsUri: options.wsUri,
                     timeout: 120_000,
                     logDebug: debug,
                     onConnected() {
                         for (const waiter of waitingForSocket) {
-                            waiter.resolve(state.ws!);
+                            waiter.resolve(state.ws);
                         }
-
                         waitingForSocket.length = 0;
                         console.log('Connected to', options.wsUri);
                         connected.value = 'connected';
@@ -314,7 +277,6 @@ export function useShv(options: VueShvOptions) {
                     onRequest: options.onRequest,
                 });
             };
-
             const shvUser = shvSessionStorage.value.shvLoginUser;
             const shvPassword = shvSessionStorage.value.shvLoginPassword;
             if (shvUser !== undefined && shvPassword !== undefined) {
@@ -324,7 +286,6 @@ export function useShv(options: VueShvOptions) {
                 doConnect(shvUser, shvPassword, 'PLAIN');
                 return;
             }
-
             azureAvailable().then(isAzureAvailable => {
                 switch (isAzureAvailable) {
                     case LoginFailureReason.NoCredentials:
@@ -337,13 +298,11 @@ export function useShv(options: VueShvOptions) {
                     case 'azureAvailable':
                         break;
                 }
-
                 const accessToken = shvLocalStorage.value.azureAccessToken;
-
                 if (accessToken !== undefined) {
                     doConnect('', accessToken, 'TOKEN');
                 }
-            }).catch((error: unknown) => {
+            }).catch((error) => {
                 console.error('Failed to fetch verify azure info, redirecting to the login page in 3 seconds', error);
                 setTimeout(() => {
                     loginFailure.value = {
@@ -354,91 +313,74 @@ export function useShv(options: VueShvOptions) {
             });
         });
     };
-
-    function makeGlobalResource<ResourceType>(options: GlobalResourceOptions<ResourceType>): () => Ref<ResourceType | undefined>;
-    function makeGlobalResource<ResourceType>(options: GlobalResourceOptions<ResourceType> & {default: ResourceType}): () => ComputedRef<ResourceType>;
-    function makeGlobalResource<ResourceType>(options: GlobalResourceOptions<ResourceType> & {default?: ResourceType}): () => ComputedRef<ResourceType> | Ref<ResourceType | undefined> {
-        const resource = ref<ResourceType>();
+    function makeGlobalResource(options) {
+        const resource = (0, vue_1.ref)();
         const resIdentifier = `${options.shvPath}:${options.method}`;
-
-        const resourceCall = makeRpcCall<ResourceType>(options.shvPath, options.method, options.validator);
+        const resourceCall = makeRpcCall(options.shvPath, options.method, options.validator);
         const refreshValue = async () => {
             const newResource = await resourceCall();
             if (newResource instanceof Error) {
                 return;
             }
-
             resource.value = newResource;
         };
-
         const initialize = async () => {
             try {
                 await refreshValue();
                 const connection = await getConnection();
-                connection.subscribe(`Global-${resIdentifier}:`, options.shvPath, options.signalName, (_path: string, _method: string, param: RpcValue) => {
-                    options.signalHandler(param, resource, async () => refreshValue().catch((error: unknown) => {
+                connection.subscribe(`Global-${resIdentifier}:`, options.shvPath, options.signalName, (_path, _method, param) => {
+                    options.signalHandler(param, resource, async () => refreshValue().catch((error) => {
                         console.error(`Failed to initialize ${resIdentifier}`, error);
                     }));
                 });
-            } catch (error) {
+            }
+            catch (error) {
                 console.error(`Failed to initialize ${resIdentifier}`, error);
             }
         };
-
         let initialized = false;
-
         return () => {
             if (!initialized) {
                 initialized = true;
-                watchEffect(() => {
+                (0, vue_1.watchEffect)(() => {
                     if (connected.value !== 'connected') {
                         return;
                     }
-
-                    initialize().catch((error: unknown) => {
+                    initialize().catch((error) => {
                         console.error(`Failed to initialize ${resIdentifier}`, error);
                     });
                 });
             }
-
             if ('default' in options) {
                 const defaultValue = options.default;
-                const withDefault = computed(() => {
+                const withDefault = (0, vue_1.computed)(() => {
                     if (resource.value === undefined) {
                         return defaultValue;
                     }
-
                     return resource.value;
                 });
                 return withDefault;
             }
-
             return resource;
         };
     }
-
-    const azureHandlerError = ref('');
-
+    const azureHandlerError = (0, vue_1.ref)('');
     const handleAzureCode = async () => {
         if (shvSessionStorage.value.azureWorkflow === undefined) {
             azureHandlerError.value = 'Azure error: no active login procedure';
             return;
         }
-
         if (options.azureCodeRedirect === undefined) {
             throw new Error('Azure redirect URL not set');
         }
-
-        const {azureCodeRedirect} = options;
-
-        return makePkce({...shvSessionStorage.value.azureWorkflow, azureCodeRedirect}).exchangeForAccessToken(globalThis.location.href).then(resp => {
+        const { azureCodeRedirect } = options;
+        return makePkce({ ...shvSessionStorage.value.azureWorkflow, azureCodeRedirect }).exchangeForAccessToken(globalThis.location.href).then(resp => {
             shvSessionStorage.value.azureWorkflow = undefined;
             const token = resp.access_token;
             if (token === undefined) {
                 azureHandlerError.value = 'Couldn\'t authenticate to Azure: unable to exchange access token';
                 return;
             }
-
             // Store the token and remove the code from the query params.
             shvLogout();
             shvLocalStorage.value.azureAccessToken = token;
@@ -447,14 +389,12 @@ export function useShv(options: VueShvOptions) {
                 azureHandlerError.value = 'Couldn\'t authenticate to Azure: no redirect URL';
                 return;
             }
-
             shvLocalStorage.value.azureRedirectTo = undefined;
             return redirectTo;
-        }).catch((error: unknown) => {
+        }).catch((error) => {
             azureHandlerError.value = `Couldn't authenticate to Azure: ${JSON.stringify(error)}`;
         });
     };
-
     return {
         azureAuth,
         azureHandlerError,
@@ -478,7 +418,7 @@ export function useShv(options: VueShvOptions) {
         shvSessionStorage,
     };
 }
-
-export const fullReloadHandler = (_param: RpcValue, _resource: unknown, reinit: () => void) => {
+const fullReloadHandler = (_param, _resource, reinit) => {
     reinit();
 };
+exports.fullReloadHandler = fullReloadHandler;