@quiltt/core 3.5.6 → 3.6.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @quiltt/core
 
+## 3.6.1
+
+### Patch Changes
+
+- [#232](https://github.com/quiltt/quiltt-js/pull/232) [`7a119af`](https://github.com/quiltt/quiltt-js/commit/7a119af8b0ba826b8df81f5eb242c002379b4e56) Thanks [@sirwolfgang](https://github.com/sirwolfgang)! - Improve typeof checks for mobile environments
+
+## 3.6.0
+
+### Minor Changes
+
+- [#229](https://github.com/quiltt/quiltt-js/pull/229) [`f688563`](https://github.com/quiltt/quiltt-js/commit/f6885635d989fb75918cb13e449ca0eec60850fc) Thanks [@zubairaziz](https://github.com/zubairaziz)! - Fix Websockets protocol variable
+
+- [#229](https://github.com/quiltt/quiltt-js/pull/229) [`f688563`](https://github.com/quiltt/quiltt-js/commit/f6885635d989fb75918cb13e449ca0eec60850fc) Thanks [@zubairaziz](https://github.com/zubairaziz)! - Fix Websockets protocol variable
+
 ## 3.5.6
 
 ### Patch Changes

package/dist/{SubscriptionLink-client-VkkcO2Yz.js → SubscriptionLink-client-DOcfhNgq.js}

@@ -1,66 +1,7 @@
 'use client';
 import { ApolloLink, Observable as Observable$1 } from '@apollo/client/core/index.js';
 import { print } from 'graphql';
-import { c as createConsumer } from './index-client-D55-rzVl.js';
-
-var name = "@quiltt/core";
-var version$1 = "3.5.6";
-
-const QUILTT_API_INSECURE = (()=>{
-    try {
-        return process.env.QUILTT_API_INSECURE;
-    } catch  {
-        return undefined;
-    }
-})();
-const QUILTT_API_DOMAIN = (()=>{
-    try {
-        return process.env.QUILTT_API_DOMAIN;
-    } catch  {
-        return undefined;
-    }
-})();
-const QUILTT_DEBUG = (()=>{
-    try {
-        return !!process.env.QUILTT_DEBUG || process.env.NODE_ENV !== 'production';
-    } catch  {
-        return false;
-    }
-})();
-const domain = QUILTT_API_DOMAIN || 'quiltt.io';
-const protocolHttp = `http${QUILTT_API_INSECURE ? '' : 's'}`;
-const protocolWebsockets = `ws${QUILTT_API_DOMAIN ? '' : '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 endpointWebsockets = `${protocolWebsockets}://api.${domain}/websockets`;
-
-/**
- * This is designed to support singletons to share the memory states across all
- * 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){
-        this.observers = [];
-        this.get = ()=>{
-            return this.state;
-        };
-        this.set = (nextState)=>{
-            if (this.state === nextState) return;
-            this.state = nextState;
-            this.observers.forEach((update)=>update(nextState));
-        };
-        this.subscribe = (observer)=>{
-            this.observers.push(observer);
-        };
-        this.unsubscribe = (observer)=>{
-            this.observers = this.observers.filter((update)=>update !== observer);
-        };
-        this.state = initalState;
-    }
-}
+import { c as createConsumer } from './index-client-BExxNScK.js';
 
 /**
  * An error and type safe wrapper for localStorage.
@@ -81,7 +22,7 @@ const endpointWebsockets = `${protocolWebsockets}://api.${domain}/websockets`;
         };
         this.isDisabled = ()=>!this.isEnabled();
         this.get = (key)=>{
-            if (typeof window === 'undefined' || !!window.expo) return undefined;
+            if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return undefined;
             try {
                 const state = window.localStorage.getItem(`quiltt.${key}`);
                 return state ? JSON.parse(state) : state;
@@ -91,7 +32,7 @@ const endpointWebsockets = `${protocolWebsockets}://api.${domain}/websockets`;
             }
         };
         this.set = (key, state)=>{
-            if (typeof window === 'undefined' || !!window.expo) return;
+            if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return;
             try {
                 if (state) {
                     window.localStorage.setItem(`quiltt.${key}`, JSON.stringify(state));
@@ -103,6 +44,7 @@ const endpointWebsockets = `${protocolWebsockets}://api.${domain}/websockets`;
             }
         };
         this.remove = (key)=>{
+            if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return;
             try {
                 window.localStorage.removeItem(`quiltt.${key}`);
             } catch (error) {
@@ -130,12 +72,37 @@ const endpointWebsockets = `${protocolWebsockets}://api.${domain}/websockets`;
                 });
             }
         };
-        if (typeof window !== 'undefined' && !window?.expo) {
+        if (typeof window !== 'undefined' && typeof window.addEventListener !== 'undefined') {
             window.addEventListener('storage', this.handleStorageEvent.bind(this));
         }
     }
 }
 
+/**
+ * This is designed to support singletons to share the memory states across all
+ * 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){
+        this.observers = [];
+        this.get = ()=>{
+            return this.state;
+        };
+        this.set = (nextState)=>{
+            if (this.state === nextState) return;
+            this.state = nextState;
+            this.observers.forEach((update)=>update(nextState));
+        };
+        this.subscribe = (observer)=>{
+            this.observers.push(observer);
+        };
+        this.unsubscribe = (observer)=>{
+            this.observers = this.observers.filter((update)=>update !== observer);
+        };
+        this.state = initalState;
+    }
+}
+
 /**
  * This is designed to support effectively an in memory key value store singleton,
  * similar to localstorage, but allows you to subscribe to changes within the current
@@ -236,6 +203,49 @@ const endpointWebsockets = `${protocolWebsockets}://api.${domain}/websockets`;
  * basically acts like shared memory when there is no localStorage.
  */ const GlobalStorage = new Storage();
 
+var name = "@quiltt/core";
+var version$1 = "3.6.1";
+
+/**
+ * Retrieves the environment variable by key, with fallback and type conversion,
+ * supporting Node.js, Vite, and potentially other runtime environments.
+ */ const getEnv = (key, fallback = undefined)=>{
+    try {
+        let value;
+        // Check if running under Node.js and use process.env
+        if (typeof process !== 'undefined' && process.env) {
+            value = process.env[key];
+        }
+        // Return the value after type conversion if necessary or use fallback
+        if (value === undefined || value === null) {
+            return fallback;
+        }
+        // Convert to boolean if the value is 'true' or 'false'
+        if (value === 'true' || value === 'false') {
+            return value === 'true';
+        }
+        // Convert to number if it's numeric
+        if (!isNaN(Number(value))) {
+            return Number(value);
+        }
+        return value;
+    } catch (error) {
+        return undefined;
+    }
+};
+const QUILTT_API_INSECURE = getEnv('QUILTT_API_INSECURE', false);
+const QUILTT_API_DOMAIN = getEnv('QUILTT_API_DOMAIN', 'quiltt.io');
+const QUILTT_DEBUG = getEnv('QUILTT_DEBUG', process?.env?.NODE_ENV !== 'production');
+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 endpointWebsockets = `${protocolWebsockets}://api.${domain}/websockets`;
+
 class ActionCableLink extends ApolloLink {
     constructor(options){
         super();
@@ -297,4 +307,4 @@ class SubscriptionLink extends ActionCableLink {
     }
 }
 
-export { GlobalStorage as G, LocalStorage as L, MemoryStorage as M, Observable as O, SubscriptionLink as S, endpointAuth as a, endpointWebsockets as b, cdnBase as c, debugging as d, endpointGraphQL as e, Storage as f, version as v };
+export { GlobalStorage as G, LocalStorage as L, MemoryStorage as M, Observable as O, SubscriptionLink as S, endpointAuth as a, Storage as b, cdnBase as c, debugging as d, endpointGraphQL as e, endpointWebsockets as f, getEnv as g, version as v };

package/dist/{index-client-D55-rzVl.js → index-client-BExxNScK.js}

@@ -1,5 +1,5 @@
 'use client';
-import { d as debugging } from './SubscriptionLink-client-VkkcO2Yz.js';
+import { d as debugging } from './SubscriptionLink-client-DOcfhNgq.js';
 
 var adapters = {
     logger: typeof globalThis !== 'undefined' ? globalThis.console : undefined,

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import { Dispatch, SetStateAction } from 'react';
 import { ApolloLink, Operation, NextLink, Observable as Observable$1, FetchResult, ApolloClientOptions, ApolloClient } from '@apollo/client/index.js';
 export { ApolloError, InMemoryCache, NormalizedCacheObject, OperationVariables, gql, useMutation, useQuery, useSubscription } from '@apollo/client/index.js';
 import { BatchHttpLink as BatchHttpLink$1 } from '@apollo/client/link/batch-http/index.js';
@@ -6,175 +5,7 @@ import * as _apollo_client from '@apollo/client';
 import { HttpLink as HttpLink$1 } from '@apollo/client/link/http/index.js';
 import { RetryLink as RetryLink$1 } from '@apollo/client/link/retry/index.js';
 import { ApolloLink as ApolloLink$1, Operation as Operation$1, NextLink as NextLink$1, Observable as Observable$2, FetchResult as FetchResult$1 } from '@apollo/client/core/index.js';
-
-declare const debugging: boolean;
-declare const version: string;
-declare const cdnBase: string;
-declare const endpointAuth: string;
-declare const endpointGraphQL: string;
-declare const endpointWebsockets: string;
-
-/** Utility types to extend default TS utilities */
-type Maybe<T> = T | null;
-type InputMaybe<T> = Maybe<T>;
-type Exact<T extends {
-    [key: string]: unknown;
-}> = {
-    [K in keyof T]: T[K];
-};
-type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
-    [SubKey in K]?: Maybe<T[SubKey]>;
-};
-type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
-    [SubKey in K]: Maybe<T[SubKey]>;
-};
-type Nullable<T> = {
-    [K in keyof T]: T[K] | null;
-};
-type Mutable<Type> = {
-    -readonly [Key in keyof Type]: Type[Key];
-};
-type DeepPartial<T> = T extends object ? {
-    [P in keyof T]?: DeepPartial<T[P]>;
-} : T;
-type DeepReadonly<T> = T extends object ? {
-    [P in keyof T]: DeepReadonly<T[P]>;
-} : T;
-declare global {
-    interface Window {
-        expo: any;
-    }
-}
-
-type JsonWebToken<T> = {
-    token: string;
-    claims: Claims<T>;
-};
-type Claims<T> = RegisteredClaims & 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;
-};
-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
- * instance of hooks to ensure that updates only process once, by storing a value
- * then notifying all subscribers when it's updated.
- */
-declare class Observable<T> {
-    private state?;
-    private observers;
-    constructor(initalState?: Maybe<T>);
-    get: () => Maybe<T> | undefined;
-    set: (nextState: Maybe<T> | undefined) => void;
-    subscribe: (observer: Observer<T>) => void;
-    unsubscribe: (observer: Observer<T>) => void;
-}
-
-/**
- * An error and type safe wrapper for localStorage.
- * It allows you to subscribe to changes;
- * but localStorage changes only fire with another
- * window updates the record.
- */
-declare class LocalStorage<T> {
-    private observers;
-    constructor();
-    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;
-    unsubscribe: (key: string, observer: Observer<T>) => void;
-    private handleStorageEvent;
-}
-
-/**
- * This is designed to support effectively an in memory key value store singleton,
- * similar to localstorage, but allows you to subscribe to changes within the current
- * window.
- */
-declare class MemoryStorage<T> {
-    private observables;
-    get: (key: string) => Maybe<T> | undefined;
-    set: (key: string, state: Maybe<T> | undefined) => void;
-    subscribe: (key: string, observer: Observer<T>) => void;
-    unsubscribe: (key: string, observer: Observer<T>) => void;
-}
-
-/**
- * This is wraps both local and memory storage to create a unified interface, that
- * allows you to subscribe to all either changes made within this window, or changes
- * made by other windows.
- */
-declare class Storage<T> {
-    private memoryStore;
-    private localStore;
-    private observers;
-    private monitors;
-    /**
-     * Checks memoryStorage before falling back to localStorage.
-     */
-    get: (key: string) => Maybe<T> | undefined;
-    /**
-     * We don't trust localStorage to always be present, so we can't rely on it to
-     * update memoryStorage based on emitted changes. So we manage our own
-     * emitting while using the underlying events to keep memoryStore in sync with
-     * localStore.
-     */
-    set: (key: string, newState: Maybe<T> | undefined) => void;
-    /**
-     * Allows you to subscribe to all changes in memory or local storage as a
-     * single event.
-     */
-    subscribe: (key: string, observer: Observer<T>) => void;
-    unsubscribe: (key: string, observer: Observer<T>) => void;
-    /**
-     * Sets bubble the changes down the stack starting with memoryStore and then
-     * localStore. memoryStore will emit changes to everything within the current
-     * window context, while localStore will emit changes to every other window
-     * context.
-     *
-     * To ensure that the other windows are updated correctly, changes to localStore
-     * need to be subscribed and updated to in memory store, which then may be subscribed
-     * to outside of storage.
-     */
-    private monitorLocalStorageChanges;
-}
-
-/**
- * This is an singleton to share the memory states across all instances; This
- * basically acts like shared memory when there is no localStorage.
- */
-declare const GlobalStorage: Storage<any>;
-
-/**
- * This is designed to support singletons to timeouts that can broadcast
- * to any observers, preventing race conditions with multiple timeouts.
- */
-declare class Timeoutable {
-    private timeout?;
-    private observers;
-    set: (callback: () => void, delay: number | undefined) => void;
-    clear: (observer: Observer<void>) => void;
-    private broadcast;
-}
+import { Dispatch, SetStateAction } from 'react';
 
 interface CallbackManager {
     onEvent(callback: ConnectorSDKOnEventCallback): void;
@@ -444,4 +275,172 @@ declare class AuthAPI {
     private body;
 }
 
-export { AuthAPI, AuthLink, AuthStrategies, BatchHttpLink, type Claims, type ConnectorSDK, type ConnectorSDKCallbackMetadata, type ConnectorSDKCallbacks, type ConnectorSDKConnectOptions, type ConnectorSDKConnector, type ConnectorSDKConnectorOptions, ConnectorSDKEventType, type ConnectorSDKOnEventCallback, type ConnectorSDKOnEventExitCallback, type ConnectorSDKOnExitAbortCallback, type ConnectorSDKOnExitErrorCallback, type ConnectorSDKOnExitSuccessCallback, type ConnectorSDKOnLoadCallback, type ConnectorSDKReconnectOptions, type DeepPartial, type DeepReadonly, ErrorLink, type Exact, ForwardableLink, GlobalStorage, HttpLink, type InputMaybe, type JsonWebToken, JsonWebTokenParse, LocalStorage, type MakeMaybe, type MakeOptional, type Maybe, MemoryStorage, type Mutable, type Nullable, Observable, type Observer, type PasscodePayload, type PrivateClaims, QuilttClient, type QuilttClientOptions, type QuilttJWT, type RegisteredClaims, RetryLink, type SessionResponse, Storage, SubscriptionLink, TerminatingLink, Timeoutable, type UnprocessableData, type UnprocessableResponse, type UsernamePayload, VersionLink, cdnBase, debugging, endpointAuth, endpointGraphQL, endpointWebsockets, version };
+/** Utility types to extend default TS utilities */
+type Maybe<T> = T | null;
+type InputMaybe<T> = Maybe<T>;
+type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+type Nullable<T> = {
+    [K in keyof T]: T[K] | null;
+};
+type Mutable<Type> = {
+    -readonly [Key in keyof Type]: Type[Key];
+};
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+type DeepReadonly<T> = T extends object ? {
+    [P in keyof T]: DeepReadonly<T[P]>;
+} : T;
+
+type Observer<T> = Dispatch<SetStateAction<Maybe<T> | undefined>>;
+/**
+ * This is designed to support singletons to share the memory states across all
+ * instance of hooks to ensure that updates only process once, by storing a value
+ * then notifying all subscribers when it's updated.
+ */
+declare class Observable<T> {
+    private state?;
+    private observers;
+    constructor(initalState?: Maybe<T>);
+    get: () => Maybe<T> | undefined;
+    set: (nextState: Maybe<T> | undefined) => void;
+    subscribe: (observer: Observer<T>) => void;
+    unsubscribe: (observer: Observer<T>) => void;
+}
+
+/**
+ * An error and type safe wrapper for localStorage.
+ * It allows you to subscribe to changes;
+ * but localStorage changes only fire with another
+ * window updates the record.
+ */
+declare class LocalStorage<T> {
+    private observers;
+    constructor();
+    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;
+    unsubscribe: (key: string, observer: Observer<T>) => void;
+    private handleStorageEvent;
+}
+
+/**
+ * This is designed to support effectively an in memory key value store singleton,
+ * similar to localstorage, but allows you to subscribe to changes within the current
+ * window.
+ */
+declare class MemoryStorage<T> {
+    private observables;
+    get: (key: string) => Maybe<T> | undefined;
+    set: (key: string, state: Maybe<T> | undefined) => void;
+    subscribe: (key: string, observer: Observer<T>) => void;
+    unsubscribe: (key: string, observer: Observer<T>) => void;
+}
+
+/**
+ * This is wraps both local and memory storage to create a unified interface, that
+ * allows you to subscribe to all either changes made within this window, or changes
+ * made by other windows.
+ */
+declare class Storage<T> {
+    private memoryStore;
+    private localStore;
+    private observers;
+    private monitors;
+    /**
+     * Checks memoryStorage before falling back to localStorage.
+     */
+    get: (key: string) => Maybe<T> | undefined;
+    /**
+     * We don't trust localStorage to always be present, so we can't rely on it to
+     * update memoryStorage based on emitted changes. So we manage our own
+     * emitting while using the underlying events to keep memoryStore in sync with
+     * localStore.
+     */
+    set: (key: string, newState: Maybe<T> | undefined) => void;
+    /**
+     * Allows you to subscribe to all changes in memory or local storage as a
+     * single event.
+     */
+    subscribe: (key: string, observer: Observer<T>) => void;
+    unsubscribe: (key: string, observer: Observer<T>) => void;
+    /**
+     * Sets bubble the changes down the stack starting with memoryStore and then
+     * localStore. memoryStore will emit changes to everything within the current
+     * window context, while localStore will emit changes to every other window
+     * context.
+     *
+     * To ensure that the other windows are updated correctly, changes to localStore
+     * need to be subscribed and updated to in memory store, which then may be subscribed
+     * to outside of storage.
+     */
+    private monitorLocalStorageChanges;
+}
+/**
+ * This is an singleton to share the memory states across all instances; This
+ * basically acts like shared memory when there is no localStorage.
+ */
+declare const GlobalStorage: Storage<any>;
+
+/**
+ * Retrieves the environment variable by key, with fallback and type conversion,
+ * supporting Node.js, Vite, and potentially other runtime environments.
+ */
+declare const getEnv: (key: string, fallback?: any) => any;
+declare const debugging: any;
+declare const version: string;
+declare const cdnBase: string;
+declare const endpointAuth: string;
+declare const endpointGraphQL: string;
+declare const endpointWebsockets: string;
+
+type JsonWebToken<T> = {
+    token: string;
+    claims: Claims<T>;
+};
+type Claims<T> = RegisteredClaims & 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;
+};
+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.
+ */
+declare class Timeoutable {
+    private timeout?;
+    private observers;
+    set: (callback: () => void, delay: number | undefined) => void;
+    clear: (observer: Observer<void>) => void;
+    private broadcast;
+}
+
+export { AuthAPI, AuthLink, AuthStrategies, BatchHttpLink, type Claims, type ConnectorSDK, type ConnectorSDKCallbackMetadata, type ConnectorSDKCallbacks, type ConnectorSDKConnectOptions, type ConnectorSDKConnector, type ConnectorSDKConnectorOptions, ConnectorSDKEventType, type ConnectorSDKOnEventCallback, type ConnectorSDKOnEventExitCallback, type ConnectorSDKOnExitAbortCallback, type ConnectorSDKOnExitErrorCallback, type ConnectorSDKOnExitSuccessCallback, type ConnectorSDKOnLoadCallback, type ConnectorSDKReconnectOptions, type DeepPartial, type DeepReadonly, ErrorLink, type Exact, ForwardableLink, GlobalStorage, HttpLink, type InputMaybe, type JsonWebToken, JsonWebTokenParse, LocalStorage, type MakeMaybe, type MakeOptional, type Maybe, MemoryStorage, type Mutable, type Nullable, Observable, type Observer, type PasscodePayload, type PrivateClaims, QuilttClient, type QuilttClientOptions, type QuilttJWT, type RegisteredClaims, RetryLink, type SessionResponse, Storage, SubscriptionLink, TerminatingLink, Timeoutable, type UnprocessableData, type UnprocessableResponse, type UsernamePayload, VersionLink, cdnBase, debugging, endpointAuth, endpointGraphQL, endpointWebsockets, getEnv, version };

package/dist/index.js

@@ -1,55 +1,13 @@
-import { G as GlobalStorage, e as endpointGraphQL, v as version, d as debugging, S as SubscriptionLink, a as endpointAuth } from './SubscriptionLink-client-VkkcO2Yz.js';
-export { L as LocalStorage, M as MemoryStorage, O as Observable, f as Storage, c as cdnBase, b as endpointWebsockets } from './SubscriptionLink-client-VkkcO2Yz.js';
 import { ApolloLink, ApolloClient } from '@apollo/client/index.js';
 export { InMemoryCache, gql, useMutation, useQuery, useSubscription } from '@apollo/client/index.js';
+import { G as GlobalStorage, e as endpointGraphQL, v as version, d as debugging, S as SubscriptionLink, a as endpointAuth } from './SubscriptionLink-client-DOcfhNgq.js';
+export { L as LocalStorage, M as MemoryStorage, O as Observable, b as Storage, c as cdnBase, f as endpointWebsockets, g as getEnv } from './SubscriptionLink-client-DOcfhNgq.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';
 import { HttpLink as HttpLink$1 } from '@apollo/client/link/http/index.js';
 import { RetryLink as RetryLink$1 } from '@apollo/client/link/retry/index.js';
 
-const MATCHER = /^(?:[\w-]+\.){2}[\w-]+$/;
-const JsonWebTokenParse = (token)=>{
-    if (typeof token === 'undefined' || token === null) return token;
-    if (!MATCHER.test(token)) {
-        console.error(`Invalid Session Token: ${token}`);
-        return;
-    }
-    const [_header, payload, _signature] = token.split('.');
-    try {
-        return {
-            token: token,
-            claims: JSON.parse(atob(payload))
-        };
-    } catch (error) {
-        console.error(`Invalid Session Token: ${error}`);
-    }
-};
-
-/**
- * This is designed to support singletons to timeouts that can broadcast
- * to any observers, preventing race conditions with multiple timeouts.
- */ class Timeoutable {
-    constructor(){
-        this.observers = [];
-        this.set = (callback, delay)=>{
-            if (this.timeout) {
-                clearTimeout(this.timeout);
-            }
-            this.observers.push(callback);
-            this.timeout = setTimeout(this.broadcast.bind(this), delay);
-        };
-        this.clear = (observer)=>{
-            this.observers = this.observers.filter((callback)=>callback !== observer);
-        };
-        // Only sends to the 1st listener, but ensures that someone is notified
-        this.broadcast = ()=>{
-            if (this.observers.length === 0) return;
-            this.observers[0](undefined);
-        };
-    }
-}
-
 var ConnectorSDKEventType;
 (function(ConnectorSDKEventType) {
     ConnectorSDKEventType["Load"] = "loaded";
@@ -286,4 +244,46 @@ class AuthAPI {
     }
 }
 
+const MATCHER = /^(?:[\w-]+\.){2}[\w-]+$/;
+const JsonWebTokenParse = (token)=>{
+    if (typeof token === 'undefined' || token === null) return token;
+    if (!MATCHER.test(token)) {
+        console.error(`Invalid Session Token: ${token}`);
+        return;
+    }
+    const [_header, payload, _signature] = token.split('.');
+    try {
+        return {
+            token: token,
+            claims: JSON.parse(atob(payload))
+        };
+    } catch (error) {
+        console.error(`Invalid Session Token: ${error}`);
+    }
+};
+
+/**
+ * This is designed to support singletons to timeouts that can broadcast
+ * to any observers, preventing race conditions with multiple timeouts.
+ */ class Timeoutable {
+    constructor(){
+        this.observers = [];
+        this.set = (callback, delay)=>{
+            if (this.timeout) {
+                clearTimeout(this.timeout);
+            }
+            this.observers.push(callback);
+            this.timeout = setTimeout(this.broadcast.bind(this), delay);
+        };
+        this.clear = (observer)=>{
+            this.observers = this.observers.filter((callback)=>callback !== observer);
+        };
+        // Only sends to the 1st listener, but ensures that someone is notified
+        this.broadcast = ()=>{
+            if (this.observers.length === 0) return;
+            this.observers[0](undefined);
+        };
+    }
+}
+
 export { AuthAPI, AuthLink, AuthStrategies, BatchHttpLink, ConnectorSDKEventType, ErrorLink, ForwardableLink, GlobalStorage, HttpLink, JsonWebTokenParse, QuilttClient, RetryLink, SubscriptionLink, TerminatingLink, Timeoutable, VersionLink, debugging, endpointAuth, endpointGraphQL, version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quiltt/core",
-  "version": "3.5.6",
+  "version": "3.6.1",
   "description": "Javascript API client and utilities for Quiltt",
   "keywords": [
     "quiltt",

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

@@ -1,4 +1,4 @@
-import { GlobalStorage } from '@/Storage'
+import { GlobalStorage } from '@/storage'
 import type { FetchResult, NextLink, Operation } from '@apollo/client/core/index.js'
 import { ApolloLink, Observable } from '@apollo/client/core/index.js'
 import { print } from 'graphql'

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

@@ -1,7 +1,7 @@
 import type { FetchResult, NextLink, Observable, Operation } from '@apollo/client/index.js'
 import { ApolloLink } from '@apollo/client/index.js'
 
-import { GlobalStorage } from '@/Storage'
+import { GlobalStorage } from '@/storage'
 
 /**
  * unauthorizedCallback only triggers in the event the token is present, and

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

@@ -1,4 +1,4 @@
-import { GlobalStorage } from '@/Storage'
+import { GlobalStorage } from '@/storage'
 
 import type { ServerError } from '@apollo/client/index.js'
 import { onError } from '@apollo/client/link/error/index.js'

package/src/api/graphql/links/actioncable/README.md

@@ -0,0 +1 @@
+This is a patched version of @rails/actioncable now that https://github.com/rails/rails/pull/47939 has been merged in and released.

package/src/configuration.ts

@@ -1,32 +1,46 @@
 import { name as packageName, version as packageVersion } from '../package.json'
 
-const QUILTT_API_INSECURE = (() => {
+/**
+ * Retrieves the environment variable by key, with fallback and type conversion,
+ * supporting Node.js, Vite, and potentially other runtime environments.
+ */
+export const getEnv = (key: string, fallback: any = undefined): any => {
   try {
-    return process.env.QUILTT_API_INSECURE
-  } catch {
-    return undefined
-  }
-})()
+    let value: string | undefined
 
-const QUILTT_API_DOMAIN = (() => {
-  try {
-    return process.env.QUILTT_API_DOMAIN
-  } catch {
+    // Check if running under Node.js and use process.env
+    if (typeof process !== 'undefined' && process.env) {
+      value = process.env[key]
+    }
+
+    // Return the value after type conversion if necessary or use fallback
+    if (value === undefined || value === null) {
+      return fallback
+    }
+
+    // Convert to boolean if the value is 'true' or 'false'
+    if (value === 'true' || value === 'false') {
+      return value === 'true'
+    }
+
+    // Convert to number if it's numeric
+    if (!isNaN(Number(value))) {
+      return Number(value)
+    }
+
+    return value
+  } catch (error) {
     return undefined
   }
-})()
+}
 
-const QUILTT_DEBUG = (() => {
-  try {
-    return !!process.env.QUILTT_DEBUG || process.env.NODE_ENV !== 'production'
-  } catch {
-    return false
-  }
-})()
+const QUILTT_API_INSECURE = getEnv('QUILTT_API_INSECURE', false)
+const QUILTT_API_DOMAIN = getEnv('QUILTT_API_DOMAIN', 'quiltt.io')
+const QUILTT_DEBUG = getEnv('QUILTT_DEBUG', process?.env?.NODE_ENV !== 'production')
 
 const domain = QUILTT_API_DOMAIN || 'quiltt.io'
 const protocolHttp = `http${QUILTT_API_INSECURE ? '' : 's'}`
-const protocolWebsockets = `ws${QUILTT_API_DOMAIN ? '' : 's'}`
+const protocolWebsockets = `ws${QUILTT_API_INSECURE ? '' : 's'}`
 
 export const debugging = QUILTT_DEBUG
 export const version = `${packageName}: v${packageVersion}`

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 './api'
 export * from './types'

package/src/{Storage → storage}/Local.ts

@@ -11,7 +11,7 @@ export class LocalStorage<T> {
   private observers: { [key: string]: Observer<T>[] } = {}
 
   constructor() {
-    if (typeof window !== 'undefined' && !window?.expo) {
+    if (typeof window !== 'undefined' && typeof window.addEventListener !== 'undefined') {
       window.addEventListener('storage', this.handleStorageEvent.bind(this))
     }
   }
@@ -29,7 +29,7 @@ export class LocalStorage<T> {
   isDisabled = (): boolean => !this.isEnabled()
 
   get = (key: string): Maybe<T> | undefined => {
-    if (typeof window === 'undefined' || !!window.expo) return undefined
+    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return undefined
 
     try {
       const state = window.localStorage.getItem(`quiltt.${key}`)
@@ -41,7 +41,7 @@ export class LocalStorage<T> {
   }
 
   set = (key: string, state: Maybe<T> | undefined): void => {
-    if (typeof window === 'undefined' || !!window.expo) return
+    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return
 
     try {
       if (state) {
@@ -55,6 +55,8 @@ export class LocalStorage<T> {
   }
 
   remove = (key: string) => {
+    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') return
+
     try {
       window.localStorage.removeItem(`quiltt.${key}`)
     } catch (error) {
@@ -88,5 +90,3 @@ export class LocalStorage<T> {
     }
   }
 }
-
-export default LocalStorage

package/src/{Storage → storage}/Memory.ts

@@ -39,5 +39,3 @@ export class MemoryStorage<T> {
     }
   }
 }
-
-export default MemoryStorage

package/src/{Storage/index.ts → storage/Storage.ts}

@@ -83,9 +83,6 @@ export class Storage<T> {
   }
 }
 
-export * from './Local'
-export * from './Memory'
-
 /**
  * This is an singleton to share the memory states across all instances; This
  * basically acts like shared memory when there is no localStorage.

package/src/storage/index.ts

@@ -0,0 +1,3 @@
+export * from './Local'
+export * from './Memory'
+export * from './Storage'

package/src/types.ts

@@ -8,8 +8,3 @@ export type Nullable<T> = { [K in keyof T]: T[K] | null }
 export type Mutable<Type> = { -readonly [Key in keyof Type]: Type[Key] }
 export type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T
 export type DeepReadonly<T> = T extends object ? { [P in keyof T]: DeepReadonly<T[P]> } : T
-declare global {
-  interface Window {
-    expo: any
-  }
-}