@quiltt/vue 5.1.2

package/dist/composables/index.cjs

@@ -0,0 +1,617 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var core = require('@quiltt/core');
+var utils = require('@quiltt/core/utils');
+
+const oauthRedirectUrlDeprecationWarning = '[Quiltt] `oauthRedirectUrl` is deprecated. Use `appLauncherUrl` instead. `oauthRedirectUrl` will be removed in the next major release.';
+
+/**
+ * Gets the Vue version from the runtime
+ */ const getVueVersion = ()=>{
+    return vue.version || 'unknown';
+};
+/**
+ * Detects if running in a Capacitor native environment
+ */ const getCapacitorInfo = ()=>{
+    if (typeof window === 'undefined') return null;
+    try {
+        if (window.Capacitor?.isNativePlatform?.()) {
+            const platform = window.Capacitor.getPlatform?.() || 'native';
+            // Map platform names to correct capitalization
+            const platformNames = {
+                ios: 'iOS',
+                android: 'Android',
+                web: 'Web'
+            };
+            const platformName = platformNames[platform.toLowerCase()] || platform;
+            return `Capacitor/${platformName}`;
+        }
+    } catch  {
+    // Ignore errors
+    }
+    return null;
+};
+/**
+ * Generates platform information string for Vue web
+ * Format: Vue/<version>; <browser>/<version>
+ * Or with Capacitor: Vue/<version>; Capacitor/<platform>; <browser>/<version>
+ */ const getPlatformInfo = ()=>{
+    const versionStr = getVueVersion();
+    const capacitorInfo = getCapacitorInfo();
+    const browserInfo = utils.getBrowserInfo();
+    if (capacitorInfo) {
+        return `Vue/${versionStr}; ${capacitorInfo}; ${browserInfo}`;
+    }
+    return `Vue/${versionStr}; ${browserInfo}`;
+};
+/**
+ * Generates User-Agent string for Vue SDK
+ * Format: Quiltt/<sdk-version> (Vue/<vue-version>; <browser>/<version>)
+ */ const getSDKAgent = (sdkVersion)=>{
+    const platformInfo = getPlatformInfo();
+    return utils.getSDKAgent(sdkVersion, platformInfo);
+};
+
+var version = "5.1.2";
+
+/**
+ * Injection keys and types for Quiltt Vue plugin
+ */ // Injection keys for Quiltt state
+const QuilttSessionKey = Symbol.for('quiltt-session');
+const QuilttSetSessionKey = Symbol.for('quiltt-set-session');
+const QuilttClientIdKey = Symbol.for('quiltt-client-id');
+
+// Initialize JWT parser
+const parse$1 = core.JsonWebTokenParse;
+/**
+ * Composable for managing Quiltt session state
+ *
+ * Provides methods for importing, creating, and revoking sessions.
+ * Session state is automatically synchronized across components.
+ * Requires QuilttPlugin provider context and throws when used without it.
+ */ const useQuilttSession = ()=>{
+    const sessionRef = vue.inject(QuilttSessionKey);
+    const setSession = vue.inject(QuilttSetSessionKey);
+    const clientIdRef = vue.inject(QuilttClientIdKey);
+    if (!sessionRef || !setSession) {
+        throw new Error('[Quiltt] useQuilttSession must be used within a component where QuilttPlugin is installed. ' + 'Make sure to call app.use(QuilttPlugin) before mounting your app.');
+    }
+    // Create a computed ref for the session
+    const session = vue.computed(()=>sessionRef.value);
+    // Create AuthAPI instance (memoized based on clientId)
+    const getAuth = ()=>new core.AuthAPI(clientIdRef?.value);
+    /**
+   * Import an existing session token
+   * Validates the token and sets it as the current session
+   */ const importSession = async (token, environmentId)=>{
+        const auth = getAuth();
+        // Is there a token?
+        if (!token) return !!sessionRef.value;
+        // Is this token already imported?
+        if (sessionRef.value && sessionRef.value.token === token) return true;
+        const jwt = parse$1(token);
+        // Is this token a valid JWT?
+        if (!jwt) return false;
+        // Is this token within the expected environment?
+        if (environmentId && jwt.claims.eid !== environmentId) return false;
+        // Is this token active?
+        const response = await auth.ping(token);
+        switch(response.status){
+            case 200:
+                setSession(token);
+                return true;
+            case 401:
+                return false;
+            default:
+                throw new Error(`AuthAPI.ping: Unexpected response status ${response.status}`);
+        }
+    };
+    /**
+   * Start authentication flow with username/email/phone
+   * Returns a session token or challenges for passcode
+   */ const identifySession = async (payload, callbacks)=>{
+        const auth = getAuth();
+        const response = await auth.identify(payload);
+        switch(response.status){
+            case 201:
+                setSession(response.data.token);
+                if (callbacks.onSuccess) return callbacks.onSuccess();
+                break;
+            case 202:
+                if (callbacks.onChallenged) return callbacks.onChallenged();
+                break;
+            case 403:
+                if (callbacks.onForbidden) return callbacks.onForbidden();
+                break;
+            case 422:
+                if (callbacks.onError) return callbacks.onError(response.data);
+                break;
+            default:
+                throw new Error(`AuthAPI.identify: Unexpected response status ${response.status}`);
+        }
+    };
+    /**
+   * Complete authentication with passcode
+   */ const authenticateSession = async (payload, callbacks)=>{
+        const auth = getAuth();
+        const response = await auth.authenticate(payload);
+        switch(response.status){
+            case 201:
+                setSession(response.data.token);
+                if (callbacks.onSuccess) return callbacks.onSuccess();
+                break;
+            case 401:
+                if (callbacks.onFailure) return callbacks.onFailure();
+                break;
+            case 422:
+                if (callbacks.onError) return callbacks.onError(response.data);
+                break;
+            default:
+                throw new Error(`AuthAPI.authenticate: Unexpected response status ${response.status}`);
+        }
+    };
+    /**
+   * Revoke the current session
+   * Invalidates the token on the server and clears local state
+   */ const revokeSession = async ()=>{
+        if (!sessionRef.value) return;
+        const auth = getAuth();
+        await auth.revoke(sessionRef.value.token);
+        setSession(null);
+    };
+    /**
+   * Forget the current session locally without server call
+   * Optionally pass a specific token to guard against async processes clearing wrong session
+   */ const forgetSession = (token)=>{
+        if (!token || sessionRef.value && token === sessionRef.value.token) {
+            setSession(null);
+        }
+    };
+    return {
+        session,
+        importSession,
+        identifySession,
+        authenticateSession,
+        revokeSession,
+        forgetSession
+    };
+};
+
+/**
+ * Load the Quiltt SDK script
+ */ const loadScript = (src, nonce)=>{
+    return new Promise((resolve, reject)=>{
+        // Check if already loaded
+        if (typeof Quiltt !== 'undefined') {
+            resolve();
+            return;
+        }
+        // Check if script is already in DOM
+        const existing = document.querySelector(`script[src^="${src.split('?')[0]}"]`);
+        if (existing) {
+            existing.addEventListener('load', ()=>resolve());
+            existing.addEventListener('error', ()=>reject(new Error('Failed to load Quiltt SDK')));
+            return;
+        }
+        const script = document.createElement('script');
+        script.src = src;
+        script.async = true;
+        if (nonce) script.nonce = nonce;
+        script.onload = ()=>resolve();
+        script.onerror = ()=>reject(new Error('Failed to load Quiltt SDK'));
+        document.head.appendChild(script);
+    });
+};
+/**
+ * Composable for managing Quiltt Connector
+ *
+ * Loads the Quiltt SDK script and provides methods to open/manage connectors.
+ * This composable can run without QuilttPlugin session context; when unavailable,
+ * it logs a warning and continues without authenticated session state.
+ */ const useQuilttConnector = (connectorId, options)=>{
+    const getConnectorId = ()=>vue.toValue(connectorId);
+    const getConnectionId = ()=>vue.toValue(options?.connectionId);
+    const getInstitution = ()=>vue.toValue(options?.institution);
+    const getOauthRedirectUrl = ()=>vue.toValue(options?.oauthRedirectUrl);
+    const getAppLauncherUri = ()=>vue.toValue(options?.appLauncherUrl) ?? getOauthRedirectUrl();
+    const session = vue.ref();
+    try {
+        const quilttSession = useQuilttSession();
+        session.value = quilttSession.session.value;
+        vue.watch(()=>quilttSession.session.value, (nextSession)=>{
+            session.value = nextSession;
+        }, {
+            immediate: true
+        });
+    } catch (error) {
+        console.warn('[Quiltt] useQuilttConnector: QuilttPlugin not found in the current app context. ' + 'Continuing without session authentication.', error);
+    }
+    const connector = vue.ref();
+    const isLoaded = vue.ref(false);
+    const isOpening = vue.ref(false);
+    const isConnectorOpen = vue.ref(false);
+    // Track previous values
+    let prevConnectionId = getConnectionId();
+    let prevConnectorId = getConnectorId();
+    let prevInstitution = getInstitution();
+    let prevAppLauncherUri = getAppLauncherUri();
+    let connectorCreated = false;
+    // Load SDK script on mount
+    vue.onMounted(async ()=>{
+        const sdkVersion = utils.extractVersionNumber(version);
+        const userAgent = getSDKAgent(sdkVersion);
+        const scriptUrl = `${core.cdnBase}/v1/connector.js?agent=${encodeURIComponent(userAgent)}`;
+        try {
+            await loadScript(scriptUrl, options?.nonce);
+            isLoaded.value = true;
+        } catch (error) {
+            console.error('[Quiltt] Failed to load SDK:', error);
+        }
+    });
+    // Update authentication when session changes
+    vue.watch(()=>session.value?.token, (token)=>{
+        if (typeof Quiltt !== 'undefined') {
+            Quiltt.authenticate(token);
+        }
+    }, {
+        immediate: true
+    });
+    // Handle script loaded
+    vue.watch(isLoaded, (loaded)=>{
+        if (!loaded || typeof Quiltt === 'undefined') return;
+        // Authenticate with current session
+        Quiltt.authenticate(session.value?.token);
+    }, {
+        immediate: true
+    });
+    vue.watch(getOauthRedirectUrl, (oauthRedirectUrl)=>{
+        if (oauthRedirectUrl !== undefined) {
+            console.warn(oauthRedirectUrlDeprecationWarning);
+        }
+    }, {
+        immediate: true
+    });
+    // Create/update connector when needed
+    const updateConnector = ()=>{
+        const currentConnectorId = getConnectorId();
+        if (!isLoaded.value || typeof Quiltt === 'undefined' || !currentConnectorId) return;
+        const currentConnectionId = getConnectionId();
+        const currentInstitution = getInstitution();
+        const currentAppLauncherUri = getAppLauncherUri();
+        // Check for changes
+        const connectionIdChanged = prevConnectionId !== currentConnectionId;
+        const connectorIdChanged = prevConnectorId !== currentConnectorId;
+        const institutionChanged = prevInstitution !== currentInstitution;
+        const appLauncherUrlChanged = prevAppLauncherUri !== currentAppLauncherUri;
+        const hasChanges = connectionIdChanged || connectorIdChanged || institutionChanged || appLauncherUrlChanged || !connectorCreated;
+        if (hasChanges) {
+            if (currentConnectionId) {
+                // Reconnect mode
+                connector.value = Quiltt.reconnect(currentConnectorId, {
+                    connectionId: currentConnectionId,
+                    appLauncherUrl: currentAppLauncherUri
+                });
+            } else {
+                // Connect mode
+                connector.value = Quiltt.connect(currentConnectorId, {
+                    institution: currentInstitution,
+                    appLauncherUrl: currentAppLauncherUri
+                });
+            }
+            connectorCreated = true;
+            prevConnectionId = currentConnectionId;
+            prevConnectorId = currentConnectorId;
+            prevInstitution = currentInstitution;
+            prevAppLauncherUri = currentAppLauncherUri;
+        }
+    };
+    // Watch for changes that require connector update
+    vue.watch([
+        isLoaded,
+        getConnectorId,
+        getConnectionId,
+        getInstitution,
+        getAppLauncherUri
+    ], updateConnector, {
+        immediate: true
+    });
+    // Register event handlers when connector changes
+    vue.watch(connector, (newConnector, oldConnector)=>{
+        if (!newConnector) return;
+        // Register handlers
+        if (options?.onEvent) {
+            newConnector.onEvent(options.onEvent);
+        }
+        newConnector.onOpen((metadata)=>{
+            isConnectorOpen.value = true;
+            options?.onOpen?.(metadata);
+        });
+        if (options?.onLoad) {
+            newConnector.onLoad(options.onLoad);
+        }
+        newConnector.onExit((type, metadata)=>{
+            isConnectorOpen.value = false;
+            options?.onExit?.(type, metadata);
+        });
+        if (options?.onExitSuccess) {
+            newConnector.onExitSuccess(options.onExitSuccess);
+        }
+        if (options?.onExitAbort) {
+            newConnector.onExitAbort(options.onExitAbort);
+        }
+        if (options?.onExitError) {
+            newConnector.onExitError(options.onExitError);
+        }
+    }, {
+        immediate: true
+    });
+    // Handle deferred opening
+    vue.watch([
+        connector,
+        isOpening
+    ], ([conn, opening])=>{
+        if (conn && opening) {
+            isOpening.value = false;
+            conn.open();
+        }
+    });
+    // Warn on unmount if connector is still open
+    vue.onUnmounted(()=>{
+        if (isConnectorOpen.value) {
+            console.error('[Quiltt] useQuilttConnector: Component unmounted while Connector is still open. ' + 'This may lead to memory leaks or unexpected behavior.');
+        }
+    });
+    /**
+   * Open the connector modal
+   */ const open = ()=>{
+        if (getConnectorId()) {
+            isOpening.value = true;
+            updateConnector();
+        } else {
+            throw new Error('Must provide connectorId to open Quiltt Connector');
+        }
+    };
+    return {
+        open
+    };
+};
+
+/**
+ * Search institutions for a connector.
+ * Requires QuilttPlugin session context and throws when used without it.
+ */ const useQuilttInstitutions = (connectorId, onErrorCallback)=>{
+    const { session } = useQuilttSession();
+    const searchTermInput = vue.ref('');
+    const searchTerm = vue.ref('');
+    const searchResults = vue.ref([]);
+    const isSearching = vue.ref(false);
+    const debounceTimer = vue.ref();
+    const abortController = vue.shallowRef();
+    const sdkVersion = utils.extractVersionNumber(version);
+    const connectorsAPI = new core.ConnectorsAPI(connectorId, getSDKAgent(sdkVersion));
+    const handleError = (message)=>{
+        const errorMessage = message || 'Unknown error occurred while searching institutions';
+        console.error('Quiltt Institutions Search Error:', errorMessage);
+        onErrorCallback?.(errorMessage);
+    };
+    const setSearchTerm = (term)=>{
+        searchTermInput.value = term;
+        if (debounceTimer.value) {
+            clearTimeout(debounceTimer.value);
+        }
+        if (term.trim().length < 2) {
+            abortController.value?.abort();
+            abortController.value = undefined;
+            searchTerm.value = '';
+            searchResults.value = [];
+            isSearching.value = false;
+            return;
+        }
+        isSearching.value = true;
+        debounceTimer.value = setTimeout(()=>{
+            searchTerm.value = term;
+        }, 350);
+    };
+    vue.watch([
+        ()=>session.value?.token,
+        searchTerm
+    ], async ([token, term])=>{
+        if (!token || !connectorId || !term || term.trim().length < 2) {
+            return;
+        }
+        abortController.value?.abort();
+        const controller = new AbortController();
+        abortController.value = controller;
+        try {
+            const response = await connectorsAPI.searchInstitutions(token, connectorId, term, controller.signal);
+            if (abortController.value !== controller || controller.signal.aborted) {
+                return;
+            }
+            if (response.status === 200) {
+                searchResults.value = response.data;
+            } else {
+                handleError(response.data.message || 'Failed to fetch institutions');
+            }
+        } catch (error) {
+            if (abortController.value === controller && !controller.signal.aborted) {
+                handleError(error?.message);
+            }
+        } finally{
+            if (abortController.value === controller && !controller.signal.aborted) {
+                isSearching.value = false;
+            }
+        }
+    }, {
+        immediate: false
+    });
+    vue.onUnmounted(()=>{
+        if (debounceTimer.value) {
+            clearTimeout(debounceTimer.value);
+        }
+        abortController.value?.abort();
+    });
+    return {
+        searchTerm: vue.computed(()=>searchTerm.value),
+        searchResults: vue.computed(()=>searchResults.value),
+        isSearching: vue.computed(()=>isSearching.value),
+        setSearchTerm
+    };
+};
+
+/**
+ * Check whether a provider link is resolvable for a connector.
+ * Requires QuilttPlugin session context and throws when used without it.
+ */ const useQuilttResolvable = (connectorId, onErrorCallback)=>{
+    const { session } = useQuilttSession();
+    const sdkVersion = utils.extractVersionNumber(version);
+    const connectorsAPI = new core.ConnectorsAPI(connectorId, getSDKAgent(sdkVersion));
+    const isLoading = vue.ref(false);
+    const isResolvable = vue.ref(null);
+    const error = vue.ref(null);
+    const handleError = (message)=>{
+        const errorMessage = message || 'Unknown error occurred while checking resolvability';
+        error.value = errorMessage;
+        console.error('Quiltt Connector Resolvable Error:', errorMessage);
+        onErrorCallback?.(errorMessage);
+    };
+    const checkResolvable = async (providerId)=>{
+        if (!session.value?.token) {
+            handleError('Missing session token');
+            return null;
+        }
+        if (!connectorId) {
+            handleError('Missing connector ID');
+            return null;
+        }
+        const hasProviderId = Object.values(providerId).some((id)=>!!id);
+        if (!hasProviderId) {
+            handleError('No provider ID specified');
+            return null;
+        }
+        isLoading.value = true;
+        error.value = null;
+        try {
+            const response = await connectorsAPI.checkResolvable(session.value.token, connectorId, providerId);
+            if (response.status === 200) {
+                const result = response.data.resolvable;
+                isResolvable.value = result;
+                return result;
+            }
+            handleError(response.data.message || 'Failed to check resolvability');
+            isResolvable.value = null;
+            return null;
+        } catch (caught) {
+            handleError(caught?.message);
+            isResolvable.value = null;
+            return null;
+        } finally{
+            isLoading.value = false;
+        }
+    };
+    return {
+        checkResolvable,
+        isLoading: vue.computed(()=>isLoading.value),
+        isResolvable: vue.computed(()=>isResolvable.value),
+        error: vue.computed(()=>error.value)
+    };
+};
+
+/**
+ * Read plugin-provided Quiltt settings.
+ * When used without QuilttPlugin context, values are undefined.
+ */ const useQuilttSettings = ()=>{
+    const clientIdRef = vue.inject(QuilttClientIdKey);
+    return {
+        clientId: vue.computed(()=>clientIdRef?.value)
+    };
+};
+
+const useStorage = (key, initialState)=>{
+    const readStorage = ()=>{
+        const current = core.GlobalStorage.get(key);
+        if (current !== undefined) {
+            return current;
+        }
+        return initialState;
+    };
+    const state = vue.ref(readStorage());
+    const setStorage = (nextState)=>{
+        const resolved = nextState instanceof Function ? nextState(state.value) : nextState;
+        if (state.value !== resolved) {
+            core.GlobalStorage.set(key, resolved);
+            state.value = resolved;
+        }
+    };
+    const handleStorageChange = (newValue)=>{
+        state.value = newValue;
+    };
+    core.GlobalStorage.subscribe(key, handleStorageChange);
+    // Use onScopeDispose for cleanup in any effect scope (components, effectScope(), etc.)
+    // This safely handles cases where composable is called outside a scope
+    if (vue.getCurrentScope()) {
+        vue.onScopeDispose(()=>{
+            core.GlobalStorage.unsubscribe(key, handleStorageChange);
+        });
+    }
+    return {
+        storage: vue.computed(()=>state.value),
+        setStorage
+    };
+};
+
+const parse = core.JsonWebTokenParse;
+const sessionTimer = new core.Timeoutable();
+const useSession = (storageKey = 'session')=>{
+    const { storage: token, setStorage } = useStorage(storageKey);
+    const session = vue.ref(parse(token.value));
+    let currentExpire = null;
+    vue.watch(token, (newToken)=>{
+        session.value = parse(newToken);
+    }, {
+        immediate: true
+    });
+    vue.watch(()=>session.value, (nextSession)=>{
+        if (currentExpire) {
+            sessionTimer.clear(currentExpire);
+            currentExpire = null;
+        }
+        if (!nextSession) {
+            return;
+        }
+        const expirationMS = nextSession.claims.exp * 1000;
+        const expire = ()=>setStorage(null);
+        currentExpire = expire;
+        if (Date.now() >= expirationMS) {
+            expire();
+            return;
+        }
+        sessionTimer.set(expire, expirationMS - Date.now());
+    }, {
+        immediate: true
+    });
+    const setSession = (nextState)=>{
+        const resolved = nextState instanceof Function ? nextState(token.value) : nextState;
+        if (token.value !== resolved && (!resolved || parse(resolved))) {
+            setStorage(resolved);
+        }
+    };
+    vue.onUnmounted(()=>{
+        if (currentExpire) {
+            sessionTimer.clear(currentExpire);
+            currentExpire = null;
+        }
+    });
+    return {
+        session: vue.computed(()=>session.value),
+        setSession
+    };
+};
+
+exports.useQuilttConnector = useQuilttConnector;
+exports.useQuilttInstitutions = useQuilttInstitutions;
+exports.useQuilttResolvable = useQuilttResolvable;
+exports.useQuilttSession = useQuilttSession;
+exports.useQuilttSettings = useQuilttSettings;
+exports.useSession = useSession;
+exports.useStorage = useStorage;