@quiltt/core 3.5.4 → 3.5.6

package/dist/index.d.ts

@@ -1,18 +1,11 @@
-import { M as Maybe, O as Observer } from './index-f53b61b3.js';
-export { D as DeepPartial, f as DeepReadonly, E as Exact, G as GlobalStorage, I as InputMaybe, L as LocalStorage, d as MakeMaybe, c as MakeOptional, b as MemoryStorage, e as Mutable, N as Nullable, a as Observable, S as Storage } from './index-f53b61b3.js';
-export { ConnectorSDK, ConnectorSDKCallbackMetadata, ConnectorSDKCallbacks, ConnectorSDKConnectOptions, ConnectorSDKConnector, ConnectorSDKConnectorOptions, ConnectorSDKEventType, ConnectorSDKOnEventCallback, ConnectorSDKOnEventExitCallback, ConnectorSDKOnExitAbortCallback, ConnectorSDKOnExitErrorCallback, ConnectorSDKOnExitSuccessCallback, ConnectorSDKOnLoadCallback, ConnectorSDKReconnectOptions } from './api/index.js';
-export { AuthLink, BatchHttpLink, ErrorLink, ForwardableLink, HttpLink, RetryLink, SubscriptionLink, TerminatingLink, VersionLink } from './api/graphql/links/index.js';
-export { QuilttClient, QuilttClientOptions } from './api/graphql/index.js';
-export { AuthAPI, AuthStrategies, PasscodePayload, SessionResponse, UnprocessableData, UnprocessableResponse, UsernamePayload } from './api/rest/index.js';
+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 'react';
-import '@apollo/client/link/batch-http/index.js';
-import '@apollo/client';
-import '@apollo/client/link/http/index.js';
-import '@apollo/client/link/retry/index.js';
-import '@apollo/client/core/index.js';
-import './consumer-c13efb94.js';
-import 'axios';
+import { BatchHttpLink as BatchHttpLink$1 } from '@apollo/client/link/batch-http/index.js';
+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;
@@ -21,6 +14,38 @@ 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>;
@@ -45,6 +70,100 @@ type PrivateClaims = {
 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.
@@ -57,4 +176,272 @@ declare class Timeoutable {
     private broadcast;
 }
 
-export { Claims, JsonWebToken, JsonWebTokenParse, Maybe, Observer, PrivateClaims, QuilttJWT, RegisteredClaims, Timeoutable, cdnBase, debugging, endpointAuth, endpointGraphQL, endpointWebsockets, version };
+interface CallbackManager {
+    onEvent(callback: ConnectorSDKOnEventCallback): void;
+    onLoad(callback: ConnectorSDKOnLoadCallback): void;
+    onExit(callback: ConnectorSDKOnEventExitCallback): void;
+    onExitSuccess(callback: ConnectorSDKOnExitSuccessCallback): void;
+    onExitAbort(callback: ConnectorSDKOnExitAbortCallback): void;
+    onExitError(callback: ConnectorSDKOnExitErrorCallback): void;
+    offEvent(callback: ConnectorSDKOnEventCallback): void;
+    offLoad(callback: ConnectorSDKOnLoadCallback): void;
+    offExit(callback: ConnectorSDKOnEventExitCallback): void;
+    offExitSuccess(callback: ConnectorSDKOnExitSuccessCallback): void;
+    offExitAbort(callback: ConnectorSDKOnExitAbortCallback): void;
+    offExitError(callback: ConnectorSDKOnExitErrorCallback): void;
+}
+interface ConnectorSDK extends CallbackManager {
+    authenticate(token: string | null | undefined): void;
+    connect(connectorId: string, options?: ConnectorSDKConnectOptions): ConnectorSDKConnector;
+    reconnect(connectorId: string, options: ConnectorSDKReconnectOptions): ConnectorSDKConnector;
+    reset(): void;
+}
+interface ConnectorSDKConnector extends CallbackManager {
+    open(): void;
+}
+/**
+ * Types for optional callbacks in the ConnectorSDK.
+ *
+ * Leaf event nodes return only metadata.
+ * Internal nodes return both event type and metadata.
+ */
+type ConnectorSDKCallbacks = {
+    onEvent?: ConnectorSDKOnEventCallback;
+    onLoad?: ConnectorSDKOnLoadCallback;
+    onExit?: ConnectorSDKOnEventExitCallback;
+    onExitSuccess?: ConnectorSDKOnExitSuccessCallback;
+    onExitAbort?: ConnectorSDKOnExitAbortCallback;
+    onExitError?: ConnectorSDKOnExitErrorCallback;
+};
+type ConnectorSDKOnEventCallback = (type: ConnectorSDKEventType, metadata: ConnectorSDKCallbackMetadata) => void;
+type ConnectorSDKOnLoadCallback = (metadata: ConnectorSDKCallbackMetadata) => void;
+type ConnectorSDKOnEventExitCallback = (type: ConnectorSDKEventType, metadata: ConnectorSDKCallbackMetadata) => void;
+type ConnectorSDKOnExitSuccessCallback = (metadata: ConnectorSDKCallbackMetadata) => void;
+type ConnectorSDKOnExitAbortCallback = (metadata: ConnectorSDKCallbackMetadata) => void;
+type ConnectorSDKOnExitErrorCallback = (metadata: ConnectorSDKCallbackMetadata) => void;
+declare enum ConnectorSDKEventType {
+    Load = "loaded",
+    ExitSuccess = "exited.successful",
+    ExitAbort = "exited.aborted",
+    ExitError = "exited.errored"
+}
+type ConnectorSDKCallbackMetadata = {
+    connectorId: string;
+    profileId?: string;
+    connectionId?: string;
+};
+type ConnectorSDKConnectOptions = ConnectorSDKCallbacks & {
+    institution?: string;
+};
+type ConnectorSDKReconnectOptions = ConnectorSDKCallbacks & {
+    connectionId: string;
+};
+type ConnectorSDKConnectorOptions = ConnectorSDKCallbacks & {
+    institution?: string;
+    connectionId?: string;
+};
+
+/**
+ * unauthorizedCallback only triggers in the event the token is present, and
+ * returns the token; This allows sessions to be forgotten without race conditions
+ * causing null sessions to kill valid sessions, or invalid sessions for killing
+ * valid sessions during rotation and networking weirdness.
+ */
+declare class AuthLink extends ApolloLink {
+    request(operation: Operation, forward: NextLink): Observable$1<FetchResult> | null;
+}
+
+declare const BatchHttpLink: BatchHttpLink$1;
+
+declare const ErrorLink: _apollo_client.ApolloLink;
+
+declare const ForwardableLink: ApolloLink;
+
+declare const HttpLink: HttpLink$1;
+
+declare const RetryLink: RetryLink$1;
+
+declare class Connection {
+    constructor(consumer: any);
+    send(data: any): boolean;
+    open(): boolean;
+    close({ allowReconnect }?: {
+        allowReconnect: boolean;
+    }): any;
+    reopen(): any;
+    getProtocol(): any;
+    isOpen(): boolean;
+    isActive(): boolean;
+    triedToReconnect(): boolean;
+    isProtocolSupported(): boolean;
+    isState(...states: any[]): boolean;
+    getState(): string | null;
+    installEventHandlers(): void;
+    uninstallEventHandlers(): void;
+}
+
+type Data = {
+    [id: string]: string | object | null | undefined;
+};
+declare class Subscription {
+    consumer: Consumer;
+    identifier: string;
+    constructor(consumer: Consumer, params: Data | undefined, mixin: Data);
+    perform(action: string, data?: Data): boolean;
+    send(data: object): boolean;
+    unsubscribe(): Subscription;
+}
+
+declare class SubscriptionGuarantor {
+    subscriptions: Subscriptions;
+    pendingSubscriptions: Array<Subscription>;
+    retryTimeout: ReturnType<typeof setTimeout> | undefined;
+    constructor(subscriptions: Subscriptions);
+    guarantee(subscription: Subscription): void;
+    forget(subscription: Subscription): void;
+    startGuaranteeing(): void;
+    stopGuaranteeing(): void;
+    retrySubscribing(): void;
+}
+
+declare class Subscriptions {
+    consumer: Consumer;
+    guarantor: SubscriptionGuarantor;
+    subscriptions: Array<Subscription>;
+    constructor(consumer: Consumer);
+    create(channelName: string, mixin: Data): Subscription;
+    add(subscription: Subscription): Subscription;
+    remove(subscription: Subscription): Subscription;
+    reject(identifier: string): Subscription[];
+    forget(subscription: Subscription): Subscription;
+    findAll(identifier: string): Subscription[];
+    reload(): void[];
+    notifyAll(callbackName: string, ...args: any[]): any[][];
+    notify(subscription: Subscription, callbackName: string, ...args: any[]): any[];
+    subscribe(subscription: Subscription): void;
+    confirmSubscription(identifier: string): void;
+    sendCommand(subscription: Subscription, command: string): boolean;
+}
+
+declare class Consumer {
+    _url: string;
+    subscriptions: Subscriptions;
+    connection: Connection;
+    subprotocols: Array<string>;
+    constructor(url: string);
+    get url(): string;
+    send(data: object): boolean;
+    connect(): boolean;
+    disconnect(): any;
+    ensureActiveConnection(): boolean | undefined;
+    addSubProtocol(subprotocol: string): void;
+}
+
+type RequestResult = FetchResult$1<{
+    [key: string]: unknown;
+}, Record<string, unknown>, Record<string, unknown>>;
+type ConnectionParams = object | ((operation: Operation$1) => object);
+declare class ActionCableLink extends ApolloLink$1 {
+    cables: {
+        [id: string]: Consumer;
+    };
+    channelName: string;
+    actionName: string;
+    connectionParams: ConnectionParams;
+    constructor(options: {
+        channelName?: string;
+        actionName?: string;
+        connectionParams?: ConnectionParams;
+    });
+    request(operation: Operation$1, _next: NextLink$1): Observable$2<RequestResult> | null;
+}
+
+declare class SubscriptionLink extends ActionCableLink {
+    constructor();
+}
+
+declare const TerminatingLink: ApolloLink;
+
+declare const VersionLink: ApolloLink;
+
+type QuilttClientOptions<T> = Omit<ApolloClientOptions<T>, 'link'>;
+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"
+}
+interface EmailInput {
+    email: string;
+    phone?: never;
+}
+interface PhoneInput {
+    phone: string;
+    email?: never;
+}
+type UsernamePayload = EmailInput | PhoneInput;
+type PasscodePayload = UsernamePayload & {
+    passcode: string;
+};
+type SessionData = {
+    token: string;
+};
+type NoContentData = null;
+type UnauthorizedData = {
+    message: string;
+    instruction: string;
+};
+type UnprocessableData = {
+    [attribute: string]: Array<string>;
+};
+type Ping = SessionData | UnauthorizedData;
+type Identify = SessionData | NoContentData | UnprocessableData;
+type Authenticate = SessionData | UnauthorizedData | UnprocessableData;
+type Revoke = NoContentData | UnauthorizedData;
+type SessionResponse = FetchResponse<SessionData>;
+type UnprocessableResponse = FetchResponse<UnprocessableData>;
+declare class AuthAPI {
+    clientId: string | undefined;
+    constructor(clientId?: string | undefined);
+    /**
+     * Response Statuses:
+     *  - 200: OK           -> Session is Valid
+     *  - 401: Unauthorized -> Session is Invalid
+     */
+    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<FetchResponse<Identify>>;
+    /**
+     * Response Statuses:
+     *  - 201: Created              -> MFA Validated, New Session Returned
+     *  - 401: Unauthorized         -> MFA Invalid
+     *  - 422: Unprocessable Entity -> Invalid Payload
+     */
+    authenticate: (payload: PasscodePayload) => Promise<FetchResponse<Authenticate>>;
+    /**
+     * Response Statuses:
+     *  - 204: No Content   -> Session Revoked
+     *  - 401: Unauthorized -> Session Not Found
+     */
+    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 };