@quiltt/core 4.2.3 → 4.3.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @quiltt/core
 
+## 4.3.0
+
+### Minor Changes
+
+- [#363](https://github.com/quiltt/quiltt-js/pull/363) [`641d766`](https://github.com/quiltt/quiltt-js/commit/641d76620ffbb99bc80fdc9998ac936883fe1d06) Thanks [@zubairaziz](https://github.com/zubairaziz)! - Upgrade rails/actioncable to v8
+
 ## 4.2.3
 
 ### Patch Changes

package/dist/{SubscriptionLink-client-BNmSIP63.js → SubscriptionLink-12s-DyFWSZbW.js}

@@ -4,75 +4,196 @@ import { Observable as Observable$1 } from '@apollo/client/utilities/index.js';
 import { createConsumer } from '@rails/actioncable';
 import { print } from 'graphql';
 
+var name = "@quiltt/core";
+var version$1 = "4.3.0";
+
+const QUILTT_API_INSECURE = (()=>{
+    try {
+        return process.env.QUILTT_API_INSECURE === 'true';
+    } catch  {
+        return false;
+    }
+})();
+const QUILTT_API_DOMAIN = (()=>{
+    try {
+        return process.env.QUILTT_API_DOMAIN;
+    } catch  {
+        return undefined;
+    }
+})();
+const QUILTT_DEBUG = (()=>{
+    try {
+        return process.env.NODE_ENV !== 'production' && process.env.QUILTT_DEBUG === 'true';
+    } catch  {
+        return false;
+    }
+})();
+const domain = QUILTT_API_DOMAIN || 'quiltt.io';
+const protocolHttp = `http${QUILTT_API_INSECURE ? '' : 's'}`;
+const protocolWebsockets = `ws${QUILTT_API_INSECURE ? '' : 's'}`;
+const debugging = QUILTT_DEBUG;
+const version = `${name}: v${version$1}`;
+const cdnBase = `${protocolHttp}://cdn.${domain}`;
+const endpointAuth = `${protocolHttp}://auth.${domain}/v1/users/session`;
+const endpointGraphQL = `${protocolHttp}://api.${domain}/v1/graphql`;
+const endpointRest = `${protocolHttp}://api.${domain}/v1`;
+const endpointWebsockets = `${protocolWebsockets}://api.${domain}/websockets`;
+
 /**
  * An error and type safe wrapper for localStorage.
  * It allows you to subscribe to changes;
- * but localStorage changes only fire with another
+ * but localStorage changes only fire when another
  * window updates the record.
  */ class LocalStorage {
-    constructor(){
+    constructor(keyPrefix = 'quiltt'){
         this.observers = {};
         this.isEnabled = ()=>{
             try {
-                localStorage.setItem('quiltt.ping', 'pong');
-                localStorage.removeItem('quiltt.ping');
+                const testKey = `${this.keyPrefix}.ping`;
+                localStorage.setItem(testKey, 'pong');
+                localStorage.removeItem(testKey);
                 return true;
-            } catch (error) {
+            } catch (_error) {
                 return false;
             }
         };
         this.isDisabled = ()=>!this.isEnabled();
         this.get = (key)=>{
-            if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return undefined;
+            if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {
+                return undefined;
+            }
+            const fullKey = this.getFullKey(key);
             try {
-                const state = window.localStorage.getItem(`quiltt.${key}`);
+                const state = window.localStorage.getItem(fullKey);
                 return state ? JSON.parse(state) : null;
             } catch (error) {
-                console.warn(`localStorage Error: "quiltt.${key}"`, error);
+                console.warn(`localStorage Error: "${fullKey}"`, error);
                 return undefined;
             }
         };
         this.set = (key, state)=>{
             if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return;
+            const fullKey = this.getFullKey(key);
             try {
-                if (state) {
-                    window.localStorage.setItem(`quiltt.${key}`, JSON.stringify(state));
+                if (state !== null && state !== undefined) {
+                    window.localStorage.setItem(fullKey, JSON.stringify(state));
                 } else {
-                    window.localStorage.removeItem(`quiltt.${key}`);
+                    window.localStorage.removeItem(fullKey);
                 }
             } catch (error) {
-                console.warn(`localStorage Error: "quiltt.${key}"`, error);
+                console.warn(`localStorage Error: "${fullKey}"`, error);
             }
         };
         this.remove = (key)=>{
+            if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return;
+            const fullKey = this.getFullKey(key);
+            try {
+                window.localStorage.removeItem(fullKey);
+            } catch (error) {
+                console.warn(`localStorage Error: "${fullKey}"`, error);
+            }
+        };
+        this.has = (key)=>{
+            return this.get(key) !== null && this.get(key) !== undefined;
+        };
+        this.clear = ()=>{
             if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return;
             try {
-                window.localStorage.removeItem(`quiltt.${key}`);
+                const keysToRemove = [];
+                for(let i = 0; i < localStorage.length; i++){
+                    const key = localStorage.key(i);
+                    if (key?.startsWith(`${this.keyPrefix}.`)) {
+                        keysToRemove.push(key);
+                    }
+                }
+                keysToRemove.forEach((key)=>{
+                    localStorage.removeItem(key);
+                });
             } catch (error) {
-                console.warn(`localStorage Error: "quiltt.${key}">`, error);
+                console.warn(`localStorage Error during clear`, error);
             }
         };
         this.subscribe = (key, observer)=>{
-            if (!this.observers[key]) this.observers[key] = [];
-            this.observers[key].push(observer);
+            const fullKey = this.getFullKey(key);
+            if (!this.observers[fullKey]) {
+                this.observers[fullKey] = [];
+            }
+            this.observers[fullKey].push(observer);
+            // Return unsubscribe function
+            return ()=>this.unsubscribe(key, observer);
         };
         this.unsubscribe = (key, observer)=>{
-            this.observers[key] = this.observers[key]?.filter((update)=>update !== observer);
+            const fullKey = this.getFullKey(key);
+            if (this.observers[fullKey]) {
+                this.observers[fullKey] = this.observers[fullKey].filter((update)=>update !== observer);
+                // Clean up empty observer arrays
+                if (this.observers[fullKey].length === 0) {
+                    delete this.observers[fullKey];
+                }
+            }
         };
-        // if there is a key, then trigger the related updates. If there is not key
-        // it means that a record has been removed and everything needs to be rechecked.
-        this.handleStorageEvent = (event)=>{
-            if (event.key?.includes('quiltt.')) {
-                const newState = event.newValue ? JSON.parse(event.newValue) : null;
+        // Get all keys that match quiltt prefix
+        this.keys = ()=>{
+            if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {
+                return [];
+            }
+            const keys = [];
+            try {
+                for(let i = 0; i < localStorage.length; i++){
+                    const key = localStorage.key(i);
+                    if (key?.startsWith(`${this.keyPrefix}.`)) {
+                        keys.push(key.replace(`${this.keyPrefix}.`, ''));
+                    }
+                }
+            } catch (error) {
+                console.warn('localStorage Error getting keys', error);
+            }
+            return keys;
+        };
+        this.getFullKey = (key)=>{
+            return `${this.keyPrefix}.${key}`;
+        };
+        /**
+   * Handle storage events from other windows/tabs
+   * If there is a key, then trigger the related updates. If there is no key
+   * it means that a record has been removed and everything needs to be rechecked.
+   */ this.handleStorageEvent = (event)=>{
+            const isQuilttKey = event.key?.startsWith(`${this.keyPrefix}.`);
+            if (isQuilttKey && event.key) {
+                // Parse the new value safely
+                let newState = null;
+                try {
+                    newState = event.newValue ? JSON.parse(event.newValue) : null;
+                } catch (error) {
+                    console.warn(`Failed to parse storage event value for ${event.key}`, error);
+                    return;
+                }
                 if (this.observers[event.key]) {
-                    this.observers[event.key].forEach((update)=>update(newState));
+                    this.observers[event.key].forEach((observer)=>{
+                        try {
+                            observer(newState);
+                        } catch (error) {
+                            console.warn(`Observer error for key ${event.key}`, error);
+                        }
+                    });
                 }
-            } else {
-                Object.entries(this.observers).forEach(([key, observers])=>{
-                    observers.forEach((update)=>update(this.get(key)));
+            } else if (!event.key) {
+                // Storage was cleared or changed in a way that doesn't specify a key
+                // Re-check all observed keys
+                Object.entries(this.observers).forEach(([fullKey, observers])=>{
+                    const shortKey = fullKey.replace(`${this.keyPrefix}.`, '');
+                    const currentValue = this.get(shortKey);
+                    observers.forEach((observer)=>{
+                        try {
+                            observer(currentValue);
+                        } catch (error) {
+                            console.warn(`Observer error for key ${fullKey}`, error);
+                        }
+                    });
                 });
             }
         };
+        this.keyPrefix = keyPrefix;
         if (typeof window !== 'undefined' && typeof window.addEventListener !== 'undefined') {
             window.addEventListener('storage', this.handleStorageEvent.bind(this));
         }
@@ -84,7 +205,7 @@ import { print } from 'graphql';
  * instance of hooks to ensure that updates only process once, by storing a value
  * then notifying all subscribers when it's updated.
  */ class Observable {
-    constructor(initalState){
+    constructor(initialState){
         this.observers = [];
         this.get = ()=>{
             return this.state;
@@ -92,7 +213,9 @@ import { print } from 'graphql';
         this.set = (nextState)=>{
             if (this.state === nextState) return;
             this.state = nextState;
-            this.observers.forEach((update)=>update(nextState));
+            this.observers.forEach((update)=>{
+                update(nextState);
+            });
         };
         this.subscribe = (observer)=>{
             this.observers.push(observer);
@@ -100,7 +223,7 @@ import { print } from 'graphql';
         this.unsubscribe = (observer)=>{
             this.observers = this.observers.filter((update)=>update !== observer);
         };
-        this.state = initalState;
+        this.state = initialState;
     }
 }
 
@@ -165,7 +288,9 @@ import { print } from 'graphql';
             this.monitorLocalStorageChanges(key);
             this.localStore.set(key, newState);
             this.memoryStore.set(key, newState);
-            this.observers[key]?.forEach((update)=>update(newState));
+            this.observers[key]?.forEach((update)=>{
+                update(newState);
+            });
         };
         /**
    * Allows you to subscribe to all changes in memory or local storage as a
@@ -193,7 +318,9 @@ import { print } from 'graphql';
                 const prevValue = this.memoryStore.get(key);
                 const newState = nextState instanceof Function ? nextState(prevValue) : nextState;
                 this.memoryStore.set(key, newState);
-                this.observers[key]?.forEach((update)=>update(newState));
+                this.observers[key]?.forEach((update)=>{
+                    update(newState);
+                });
             });
         };
     }
@@ -203,41 +330,6 @@ import { print } from 'graphql';
  * basically acts like shared memory when there is no localStorage.
  */ const GlobalStorage = new Storage();
 
-var name = "@quiltt/core";
-var version$1 = "4.2.3";
-
-const QUILTT_API_INSECURE = (()=>{
-    try {
-        return process.env.QUILTT_API_INSECURE === 'true';
-    } catch  {
-        return false;
-    }
-})();
-const QUILTT_API_DOMAIN = (()=>{
-    try {
-        return process.env.QUILTT_API_DOMAIN;
-    } catch  {
-        return undefined;
-    }
-})();
-const QUILTT_DEBUG = (()=>{
-    try {
-        return process.env.NODE_ENV !== 'production' && process.env.QUILTT_DEBUG === 'true';
-    } catch  {
-        return false;
-    }
-})();
-const domain = QUILTT_API_DOMAIN || 'quiltt.io';
-const protocolHttp = `http${QUILTT_API_INSECURE ? '' : 's'}`;
-const protocolWebsockets = `ws${QUILTT_API_INSECURE ? '' : 's'}`;
-const debugging = QUILTT_DEBUG;
-const version = `${name}: v${version$1}`;
-const cdnBase = `${protocolHttp}://cdn.${domain}`;
-const endpointAuth = `${protocolHttp}://auth.${domain}/v1/users/session`;
-const endpointGraphQL = `${protocolHttp}://api.${domain}/v1/graphql`;
-const endpointRest = `${protocolHttp}://api.${domain}/v1`;
-const endpointWebsockets = `${protocolWebsockets}://api.${domain}/websockets`;
-
 class ActionCableLink extends ApolloLink {
     constructor(options){
         super();
@@ -299,4 +391,4 @@ class SubscriptionLink extends ActionCableLink {
     }
 }
 
-export { GlobalStorage as G, LocalStorage as L, MemoryStorage as M, Observable as O, SubscriptionLink as S, endpointAuth as a, endpointRest as b, Storage as c, debugging as d, endpointGraphQL as e, cdnBase as f, endpointWebsockets as g, version as v };
+export { GlobalStorage as G, LocalStorage as L, MemoryStorage as M, Observable as O, SubscriptionLink as S, endpointAuth as a, endpointRest as b, cdnBase as c, debugging as d, endpointGraphQL as e, endpointWebsockets as f, Storage as g, version as v };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as _apollo_client_core from '@apollo/client/core';
-import { Operation, NextLink, FetchResult, ApolloClientOptions, NormalizedCacheObject } from '@apollo/client/core';
+import { ApolloClientOptions, NormalizedCacheObject, Operation, NextLink, FetchResult } from '@apollo/client/core';
 export { ApolloError, OperationVariables } from '@apollo/client/core';
-import { ApolloLink, ApolloClient } from '@apollo/client/core/index.js';
+import { ApolloClient, ApolloLink } from '@apollo/client/core/index.js';
 export { gql } from '@apollo/client/core/index.js';
 import { Observable as Observable$1 } from '@apollo/client/utilities';
 import { BatchHttpLink as BatchHttpLink$1 } from '@apollo/client/link/batch-http/index.js';
@@ -10,8 +10,8 @@ import { RetryLink as RetryLink$1 } from '@apollo/client/link/retry/index.js';
 import { Observable as Observable$2 } from '@apollo/client/utilities/index.js';
 import { Consumer } from '@rails/actioncable';
 import { Dispatch, SetStateAction } from 'react';
-export { InMemoryCache } from '@apollo/client/cache/index.js';
 export { NormalizedCacheObject } from '@apollo/client/cache';
+export { InMemoryCache } from '@apollo/client/cache/index.js';
 export { useMutation, useQuery, useSubscription } from '@apollo/client/react/hooks/index.js';
 
 interface CallbackManager {
@@ -105,6 +105,10 @@ type ConnectorSDKCallbackMetadata = {
     profileId?: string;
     /** The ID of the Connection that was created or reconnected */
     connectionId?: string;
+    /** The Connector Session Object */
+    connectorSession?: {
+        id: string;
+    };
 };
 /**
   Options for the standard Connect flow
@@ -122,7 +126,11 @@ type ConnectorSDKReconnectOptions = ConnectorSDKCallbacks & {
     /** The ID of the Connection to reconnect */
     connectionId: string;
 };
-/** Options to initialize Connector */
+/** Options to initialize Connector
+ *
+ *  @todo: refactor into a union type - it's either or.
+ *  Union types only allow direct access to properties that exist on all branches, not properties unique to individual branches.
+ */
 type ConnectorSDKConnectorOptions = ConnectorSDKCallbacks & {
     /** The Institution ID or search term to connect */
     institution?: string;
@@ -132,6 +140,11 @@ type ConnectorSDKConnectorOptions = ConnectorSDKCallbacks & {
     nonce?: string;
 };
 
+type QuilttClientOptions<T> = Omit<ApolloClientOptions<T>, 'link'>;
+declare class QuilttClient extends ApolloClient<NormalizedCacheObject> {
+    constructor(options: QuilttClientOptions<NormalizedCacheObject>);
+}
+
 /**
  * unauthorizedCallback only triggers in the event the token is present, and
  * returns the token; This allows sessions to be forgotten without race conditions
@@ -179,11 +192,6 @@ declare const TerminatingLink: ApolloLink;
 
 declare const VersionLink: ApolloLink;
 
-type QuilttClientOptions<T> = Omit<ApolloClientOptions<T>, 'link'>;
-declare class QuilttClient extends ApolloClient<NormalizedCacheObject> {
-    constructor(options: QuilttClientOptions<NormalizedCacheObject>);
-}
-
 type FetchResponse<T> = {
     data: T;
     status: number;
@@ -287,9 +295,16 @@ declare class InstitutionsAPI {
     search: (token: string, connectorId: string, term: string, signal?: AbortSignal) => Promise<FetchResponse<Search>>;
     private config;
     private validateStatus;
-    private body;
 }
 
+declare const debugging: boolean;
+declare const version: string;
+declare const cdnBase: string;
+declare const endpointAuth: string;
+declare const endpointGraphQL: string;
+declare const endpointRest: string;
+declare const endpointWebsockets: string;
+
 /** Utility types to extend default TS utilities */
 type Maybe<T> = T | null;
 type InputMaybe<T> = Maybe<T>;
@@ -317,6 +332,31 @@ type DeepReadonly<T> = T extends object ? {
     [P in keyof T]: DeepReadonly<T[P]>;
 } : T;
 
+type RegisteredClaims = {
+    iss: string;
+    sub: string;
+    aud: string;
+    exp: number;
+    nbf: number;
+    iat: number;
+    jti: string;
+};
+type PrivateClaims = {
+    oid: string;
+    eid: string;
+    cid: string;
+    aid: string;
+    ver: number;
+    rol: 'basic' | 'core' | 'manager' | 'super-admin';
+};
+type Claims<T> = RegisteredClaims & T;
+type JsonWebToken<T> = {
+    token: string;
+    claims: Claims<T>;
+};
+type QuilttJWT = JsonWebToken<PrivateClaims>;
+declare const JsonWebTokenParse: <T>(token: Maybe<string> | undefined) => Maybe<JsonWebToken<T>> | undefined;
+
 type Observer<T> = Dispatch<SetStateAction<Maybe<T> | undefined>>;
 /**
  * This is designed to support singletons to share the memory states across all
@@ -326,7 +366,7 @@ type Observer<T> = Dispatch<SetStateAction<Maybe<T> | undefined>>;
 declare class Observable<T> {
     private state?;
     private observers;
-    constructor(initalState?: Maybe<T>);
+    constructor(initialState?: Maybe<T>);
     get: () => Maybe<T> | undefined;
     set: (nextState: Maybe<T> | undefined) => void;
     subscribe: (observer: Observer<T>) => void;
@@ -336,19 +376,29 @@ declare class Observable<T> {
 /**
  * An error and type safe wrapper for localStorage.
  * It allows you to subscribe to changes;
- * but localStorage changes only fire with another
+ * but localStorage changes only fire when another
  * window updates the record.
  */
-declare class LocalStorage<T> {
+declare class LocalStorage<T = any> {
     private observers;
-    constructor();
+    private readonly keyPrefix;
+    constructor(keyPrefix?: string);
     isEnabled: () => boolean;
     isDisabled: () => boolean;
     get: (key: string) => Maybe<T> | undefined;
     set: (key: string, state: Maybe<T> | undefined) => void;
     remove: (key: string) => void;
-    subscribe: (key: string, observer: Observer<T>) => void;
+    has: (key: string) => boolean;
+    clear: () => void;
+    subscribe: (key: string, observer: Observer<T>) => (() => void);
     unsubscribe: (key: string, observer: Observer<T>) => void;
+    keys: () => string[];
+    private getFullKey;
+    /**
+     * Handle storage events from other windows/tabs
+     * If there is a key, then trigger the related updates. If there is no key
+     * it means that a record has been removed and everything needs to be rechecked.
+     */
     private handleStorageEvent;
 }
 
@@ -410,39 +460,6 @@ declare class Storage<T> {
  */
 declare const GlobalStorage: Storage<any>;
 
-declare const debugging: boolean;
-declare const version: string;
-declare const cdnBase: string;
-declare const endpointAuth: string;
-declare const endpointGraphQL: string;
-declare const endpointRest: string;
-declare const endpointWebsockets: string;
-
-type RegisteredClaims = {
-    iss: string;
-    sub: string;
-    aud: string;
-    exp: number;
-    nbf: number;
-    iat: number;
-    jti: string;
-};
-type PrivateClaims = {
-    oid: string;
-    eid: string;
-    cid: string;
-    aid: string;
-    ver: number;
-    rol: 'basic' | 'core' | 'manager' | 'super-admin';
-};
-type Claims<T> = RegisteredClaims & T;
-type JsonWebToken<T> = {
-    token: string;
-    claims: Claims<T>;
-};
-type QuilttJWT = JsonWebToken<PrivateClaims>;
-declare const JsonWebTokenParse: <T>(token: Maybe<string> | undefined) => Maybe<JsonWebToken<T>> | undefined;
-
 /**
  * This is designed to support singletons to timeouts that can broadcast
  * to any observers, preventing race conditions with multiple timeouts.

package/dist/index.js

@@ -1,7 +1,7 @@
 import { ApolloLink, ApolloClient } from '@apollo/client/core/index.js';
 export { gql } from '@apollo/client/core/index.js';
-import { G as GlobalStorage, e as endpointGraphQL, v as version, d as debugging, S as SubscriptionLink, a as endpointAuth, b as endpointRest } from './SubscriptionLink-client-BNmSIP63.js';
-export { L as LocalStorage, M as MemoryStorage, O as Observable, c as Storage, f as cdnBase, g as endpointWebsockets } from './SubscriptionLink-client-BNmSIP63.js';
+import { G as GlobalStorage, e as endpointGraphQL, v as version, d as debugging, S as SubscriptionLink, a as endpointAuth, b as endpointRest } from './SubscriptionLink-12s-DyFWSZbW.js';
+export { L as LocalStorage, M as MemoryStorage, O as Observable, g as Storage, c as cdnBase, f as endpointWebsockets } from './SubscriptionLink-12s-DyFWSZbW.js';
 import { BatchHttpLink as BatchHttpLink$1 } from '@apollo/client/link/batch-http/index.js';
 import crossfetch from 'cross-fetch';
 import { onError } from '@apollo/client/link/error/index.js';
@@ -285,17 +285,6 @@ class InstitutionsAPI {
             };
         };
         this.validateStatus = (status)=>status < 500 && status !== 429;
-        this.body = (payload)=>{
-            if (!this.clientId) {
-                console.error('Quiltt Client ID is not set. Unable to identify & authenticate');
-            }
-            return {
-                session: {
-                    clientId: this.clientId,
-                    ...payload
-                }
-            };
-        };
         this.clientId = clientId;
         this.agent = agent;
     }
@@ -329,7 +318,10 @@ const JsonWebTokenParse = (token)=>{
             if (this.timeout) {
                 clearTimeout(this.timeout);
             }
-            this.observers.push(callback);
+            // Replace all observers with the new one
+            this.observers = [
+                callback
+            ];
             this.timeout = setTimeout(this.broadcast.bind(this), delay);
         };
         this.clear = (observer)=>{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quiltt/core",
-  "version": "4.2.3",
+  "version": "4.3.0",
   "description": "Javascript API client and utilities for Quiltt",
   "keywords": [
     "quiltt",
@@ -32,21 +32,21 @@
   ],
   "main": "dist/index.js",
   "dependencies": {
-    "@apollo/client": "^3.12.4",
-    "@rails/actioncable": "^7.2.201",
+    "@apollo/client": "^3.14.0",
+    "@rails/actioncable": "^8.0.300",
     "braces": "^3.0.3",
     "cross-fetch": "^4.0.0",
     "graphql": "^16.10.0",
     "graphql-ruby-client": "^1.14.5"
   },
   "devDependencies": {
-    "@biomejs/biome": "1.9.4",
-    "@types/node": "22.18.1",
+    "@biomejs/biome": "2.2.4",
+    "@types/node": "22.18.6",
     "@types/rails__actioncable": "6.1.11",
-    "@types/react": "18.3.20",
-    "bunchee": "6.3.4",
+    "@types/react": "18.3.23",
+    "bunchee": "6.6.0",
     "rimraf": "6.0.1",
-    "typescript": "5.8.3"
+    "typescript": "5.9.2"
   },
   "tags": [
     "quiltt"

package/src/Observable.ts

@@ -1,4 +1,5 @@
 import type { Dispatch, SetStateAction } from 'react'
+
 import type { Maybe } from './types'
 
 export type Observer<T> = Dispatch<SetStateAction<Maybe<T> | undefined>>
@@ -12,8 +13,8 @@ export class Observable<T> {
   private state?: Maybe<T>
   private observers: Observer<T>[] = []
 
-  constructor(initalState?: Maybe<T>) {
-    this.state = initalState
+  constructor(initialState?: Maybe<T>) {
+    this.state = initialState
   }
 
   get = () => {
@@ -24,7 +25,9 @@ export class Observable<T> {
     if (this.state === nextState) return
 
     this.state = nextState
-    this.observers.forEach((update) => update(nextState))
+    this.observers.forEach((update) => {
+      update(nextState)
+    })
   }
 
   subscribe = (observer: Observer<T>) => {

package/src/Timeoutable.ts

@@ -13,7 +13,8 @@ export class Timeoutable {
       clearTimeout(this.timeout)
     }
 
-    this.observers.push(callback)
+    // Replace all observers with the new one
+    this.observers = [callback]
     this.timeout = setTimeout(this.broadcast.bind(this), delay)
   }
 

package/src/api/browser.ts

@@ -112,6 +112,10 @@ export type ConnectorSDKCallbackMetadata = {
   profileId?: string
   /** The ID of the Connection that was created or reconnected */
   connectionId?: string
+  /** The Connector Session Object */
+  connectorSession?: {
+    id: string
+  }
 }
 
 /**
@@ -132,15 +136,16 @@ export type ConnectorSDKReconnectOptions = ConnectorSDKCallbacks & {
   connectionId: string
 }
 
-/** Options to initialize Connector */
-// @todo: refactor into a union type - it's either or.
+/** Options to initialize Connector
+ *
+ *  @todo: refactor into a union type - it's either or.
+ *  Union types only allow direct access to properties that exist on all branches, not properties unique to individual branches.
+ */
 export type ConnectorSDKConnectorOptions = ConnectorSDKCallbacks & {
   /** The Institution ID or search term to connect */
   institution?: string
-
   /** The ID of the Connection to reconnect */
   connectionId?: string
-
   /** The nonce to use for the script tag */
   nonce?: string
 }

package/src/api/graphql/client.ts

@@ -3,6 +3,7 @@ import { ApolloClient, ApolloLink } from '@apollo/client/core/index.js'
 import type { DefinitionNode, OperationDefinitionNode } from 'graphql'
 
 import { debugging } from '@/configuration'
+
 import {
   AuthLink,
   BatchHttpLink,
@@ -58,10 +59,9 @@ export class QuilttClient extends ApolloClient<NormalizedCacheObject> {
 */
 
 /** Client and Tooling */
-export { gql } from '@apollo/client/core/index.js'
+export type { NormalizedCacheObject } from '@apollo/client/cache'
 export { InMemoryCache } from '@apollo/client/cache/index.js'
 export type { ApolloError, OperationVariables } from '@apollo/client/core'
-export type { NormalizedCacheObject } from '@apollo/client/cache'
-
+export { gql } from '@apollo/client/core/index.js'
 /** React hooks used by @quiltt/react-native and @quiltt/react */
 export { useMutation, useQuery, useSubscription } from '@apollo/client/react/hooks/index.js'

package/src/api/graphql/index.ts

@@ -1,2 +1,2 @@
-export * from './links'
 export * from './client'
+export * from './links'

package/src/api/graphql/links/ActionCableLink.ts

@@ -1,9 +1,8 @@
 import type { FetchResult, NextLink, Operation } from '@apollo/client/core'
 import { ApolloLink } from '@apollo/client/core/index.js'
 import { Observable } from '@apollo/client/utilities/index.js'
-
-import { createConsumer } from '@rails/actioncable'
 import type { Consumer } from '@rails/actioncable'
+import { createConsumer } from '@rails/actioncable'
 import { print } from 'graphql'
 
 import { endpointWebsockets } from '@/configuration'

package/src/api/rest/institutions.ts

@@ -55,16 +55,16 @@ export class InstitutionsAPI {
 
   private validateStatus = (status: number) => status < 500 && status !== 429
 
-  private body = (payload: any) => {
-    if (!this.clientId) {
-      console.error('Quiltt Client ID is not set. Unable to identify & authenticate')
-    }
+  // private body = (payload: any) => {
+  //   if (!this.clientId) {
+  //     console.error('Quiltt Client ID is not set. Unable to identify & authenticate')
+  //   }
 
-    return {
-      session: {
-        clientId: this.clientId,
-        ...payload,
-      },
-    }
-  }
+  //   return {
+  //     session: {
+  //       clientId: this.clientId,
+  //       ...payload,
+  //     },
+  //   }
+  // }
 }

package/src/index.ts

@@ -1,7 +1,7 @@
 export * from './api'
-export * from './storage'
 export * from './configuration'
 export * from './JsonWebToken'
 export * from './Observable'
+export * from './storage'
 export * from './Timeoutable'
 export * from './types'

package/src/storage/Local.ts

@@ -4,13 +4,16 @@ import type { Maybe } from '@/types'
 /**
  * An error and type safe wrapper for localStorage.
  * It allows you to subscribe to changes;
- * but localStorage changes only fire with another
+ * but localStorage changes only fire when another
  * window updates the record.
  */
-export class LocalStorage<T> {
+export class LocalStorage<T = any> {
   private observers: { [key: string]: Observer<T>[] } = {}
+  private readonly keyPrefix: string
+
+  constructor(keyPrefix = 'quiltt') {
+    this.keyPrefix = keyPrefix
 
-  constructor() {
     if (typeof window !== 'undefined' && typeof window.addEventListener !== 'undefined') {
       window.addEventListener('storage', this.handleStorageEvent.bind(this))
     }
@@ -18,10 +21,11 @@ export class LocalStorage<T> {
 
   isEnabled = (): boolean => {
     try {
-      localStorage.setItem('quiltt.ping', 'pong')
-      localStorage.removeItem('quiltt.ping')
+      const testKey = `${this.keyPrefix}.ping`
+      localStorage.setItem(testKey, 'pong')
+      localStorage.removeItem(testKey)
       return true
-    } catch (error) {
+    } catch (_error) {
       return false
     }
   }
@@ -29,14 +33,16 @@ export class LocalStorage<T> {
   isDisabled = (): boolean => !this.isEnabled()
 
   get = (key: string): Maybe<T> | undefined => {
-    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined')
+    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {
       return undefined
+    }
 
+    const fullKey = this.getFullKey(key)
     try {
-      const state = window.localStorage.getItem(`quiltt.${key}`)
+      const state = window.localStorage.getItem(fullKey)
       return state ? (JSON.parse(state) as T) : null
     } catch (error) {
-      console.warn(`localStorage Error: "quiltt.${key}"`, error)
+      console.warn(`localStorage Error: "${fullKey}"`, error)
       return undefined
     }
   }
@@ -44,49 +50,143 @@ export class LocalStorage<T> {
   set = (key: string, state: Maybe<T> | undefined): void => {
     if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return
 
+    const fullKey = this.getFullKey(key)
     try {
-      if (state) {
-        window.localStorage.setItem(`quiltt.${key}`, JSON.stringify(state))
+      if (state !== null && state !== undefined) {
+        window.localStorage.setItem(fullKey, JSON.stringify(state))
       } else {
-        window.localStorage.removeItem(`quiltt.${key}`)
+        window.localStorage.removeItem(fullKey)
       }
     } catch (error) {
-      console.warn(`localStorage Error: "quiltt.${key}"`, error)
+      console.warn(`localStorage Error: "${fullKey}"`, error)
     }
   }
 
-  remove = (key: string) => {
+  remove = (key: string): void => {
     if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return
 
+    const fullKey = this.getFullKey(key)
     try {
-      window.localStorage.removeItem(`quiltt.${key}`)
+      window.localStorage.removeItem(fullKey)
     } catch (error) {
-      console.warn(`localStorage Error: "quiltt.${key}">`, error)
+      console.warn(`localStorage Error: "${fullKey}"`, error)
+    }
+  }
+
+  has = (key: string): boolean => {
+    return this.get(key) !== null && this.get(key) !== undefined
+  }
+
+  clear = (): void => {
+    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return
+
+    try {
+      const keysToRemove: string[] = []
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i)
+        if (key?.startsWith(`${this.keyPrefix}.`)) {
+          keysToRemove.push(key)
+        }
+      }
+      keysToRemove.forEach((key) => {
+        localStorage.removeItem(key)
+      })
+    } catch (error) {
+      console.warn(`localStorage Error during clear`, error)
+    }
+  }
+
+  subscribe = (key: string, observer: Observer<T>): (() => void) => {
+    const fullKey = this.getFullKey(key)
+
+    if (!this.observers[fullKey]) {
+      this.observers[fullKey] = []
     }
+
+    this.observers[fullKey].push(observer)
+
+    // Return unsubscribe function
+    return () => this.unsubscribe(key, observer)
   }
 
-  subscribe = (key: string, observer: Observer<T>) => {
-    if (!this.observers[key]) this.observers[key] = []
+  unsubscribe = (key: string, observer: Observer<T>): void => {
+    const fullKey = this.getFullKey(key)
 
-    this.observers[key].push(observer)
+    if (this.observers[fullKey]) {
+      this.observers[fullKey] = this.observers[fullKey].filter((update) => update !== observer)
+
+      // Clean up empty observer arrays
+      if (this.observers[fullKey].length === 0) {
+        delete this.observers[fullKey]
+      }
+    }
   }
 
-  unsubscribe = (key: string, observer: Observer<T>) => {
-    this.observers[key] = this.observers[key]?.filter((update) => update !== observer)
+  // Get all keys that match quiltt prefix
+  keys = (): string[] => {
+    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {
+      return []
+    }
+
+    const keys: string[] = []
+    try {
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i)
+        if (key?.startsWith(`${this.keyPrefix}.`)) {
+          keys.push(key.replace(`${this.keyPrefix}.`, ''))
+        }
+      }
+    } catch (error) {
+      console.warn('localStorage Error getting keys', error)
+    }
+    return keys
+  }
+
+  private getFullKey = (key: string): string => {
+    return `${this.keyPrefix}.${key}`
   }
 
-  // if there is a key, then trigger the related updates. If there is not key
-  // it means that a record has been removed and everything needs to be rechecked.
-  private handleStorageEvent = (event: StorageEvent) => {
-    if (event.key?.includes('quiltt.')) {
-      const newState = event.newValue ? JSON.parse(event.newValue) : null
+  /**
+   * Handle storage events from other windows/tabs
+   * If there is a key, then trigger the related updates. If there is no key
+   * it means that a record has been removed and everything needs to be rechecked.
+   */
+  private handleStorageEvent = (event: StorageEvent): void => {
+    const isQuilttKey = event.key?.startsWith(`${this.keyPrefix}.`)
+
+    if (isQuilttKey && event.key) {
+      // Parse the new value safely
+      let newState: T | null = null
+      try {
+        newState = event.newValue ? JSON.parse(event.newValue) : null
+      } catch (error) {
+        console.warn(`Failed to parse storage event value for ${event.key}`, error)
+        return
+      }
 
       if (this.observers[event.key]) {
-        this.observers[event.key].forEach((update) => update(newState))
+        this.observers[event.key].forEach((observer) => {
+          try {
+            observer(newState)
+          } catch (error) {
+            console.warn(`Observer error for key ${event.key}`, error)
+          }
+        })
       }
-    } else {
-      Object.entries(this.observers).forEach(([key, observers]) => {
-        observers.forEach((update) => update(this.get(key)))
+    } else if (!event.key) {
+      // Storage was cleared or changed in a way that doesn't specify a key
+      // Re-check all observed keys
+      Object.entries(this.observers).forEach(([fullKey, observers]) => {
+        const shortKey = fullKey.replace(`${this.keyPrefix}.`, '')
+        const currentValue = this.get(shortKey)
+
+        observers.forEach((observer) => {
+          try {
+            observer(currentValue)
+          } catch (error) {
+            console.warn(`Observer error for key ${fullKey}`, error)
+          }
+        })
       })
     }
   }

package/src/storage/Memory.ts

@@ -1,5 +1,5 @@
-import { Observable } from '@/Observable'
 import type { Observer } from '@/Observable'
+import { Observable } from '@/Observable'
 import type { Maybe } from '@/types'
 
 /**

package/src/storage/Storage.ts

@@ -41,7 +41,9 @@ export class Storage<T> {
     this.localStore.set(key, newState)
     this.memoryStore.set(key, newState)
 
-    this.observers[key]?.forEach((update) => update(newState))
+    this.observers[key]?.forEach((update) => {
+      update(newState)
+    })
   }
 
   /**
@@ -77,7 +79,9 @@ export class Storage<T> {
       const newState = nextState instanceof Function ? nextState(prevValue) : nextState
 
       this.memoryStore.set(key, newState)
-      this.observers[key]?.forEach((update) => update(newState))
+      this.observers[key]?.forEach((update) => {
+        update(newState)
+      })
     })
   }
 }