@quiltt/core 3.5.5 → 3.6.0

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,176 +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';
-import { AxiosResponse } from 'axios';
-
-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;
@@ -370,6 +200,14 @@ declare class QuilttClient<T> extends ApolloClient<T> {
     constructor(options: QuilttClientOptions<T>);
 }
 
+type FetchResponse<T> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Headers;
+    ok: boolean;
+};
+
 declare enum AuthStrategies {
     Email = "email",
     Phone = "phone"
@@ -389,7 +227,7 @@ type PasscodePayload = UsernamePayload & {
 type SessionData = {
     token: string;
 };
-type NoContentData = void;
+type NoContentData = null;
 type UnauthorizedData = {
     message: string;
     instruction: string;
@@ -401,8 +239,8 @@ type Ping = SessionData | UnauthorizedData;
 type Identify = SessionData | NoContentData | UnprocessableData;
 type Authenticate = SessionData | UnauthorizedData | UnprocessableData;
 type Revoke = NoContentData | UnauthorizedData;
-type SessionResponse = AxiosResponse<SessionData>;
-type UnprocessableResponse = AxiosResponse<UnprocessableData>;
+type SessionResponse = FetchResponse<SessionData>;
+type UnprocessableResponse = FetchResponse<UnprocessableData>;
 declare class AuthAPI {
     clientId: string | undefined;
     constructor(clientId?: string | undefined);
@@ -411,30 +249,203 @@ declare class AuthAPI {
      *  - 200: OK           -> Session is Valid
      *  - 401: Unauthorized -> Session is Invalid
      */
-    ping: (token: string) => Promise<AxiosResponse<Ping, any>>;
+    ping: (token: string) => Promise<FetchResponse<Ping>>;
     /**
      * Response Statuses:
      *  - 201: Created              -> Profile Created, New Session Returned
      *  - 202: Accepted             -> Profile Found, MFA Code Sent for `authenticate`
      *  - 422: Unprocessable Entity -> Invalid Payload
      */
-    identify: (payload: UsernamePayload) => Promise<AxiosResponse<Identify, any>>;
+    identify: (payload: UsernamePayload) => Promise<FetchResponse<Identify>>;
     /**
      * Response Statuses:
      *  - 201: Created              -> MFA Validated, New Session Returned
      *  - 401: Unauthorized         -> MFA Invalid
      *  - 422: Unprocessable Entity -> Invalid Payload
      */
-    authenticate: (payload: PasscodePayload) => Promise<AxiosResponse<Authenticate, any>>;
+    authenticate: (payload: PasscodePayload) => Promise<FetchResponse<Authenticate>>;
     /**
      * Response Statuses:
      *  - 204: No Content   -> Session Revoked
      *  - 401: Unauthorized -> Session Not Found
      */
-    revoke: (token: string) => Promise<AxiosResponse<Revoke, any>>;
+    revoke: (token: string) => Promise<FetchResponse<Revoke>>;
     private config;
     private validateStatus;
     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;
+declare global {
+    interface Window {
+        expo: any;
+    }
+}
+
+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 };