@pelican-identity/auth-core 1.2.9 → 1.2.10

package/README.md

@@ -13,11 +13,6 @@ The Vanilla SDK provides a framework-agnostic way to integrate Pelican authentic
 Ideal for projects without a build step. Includes the UI and logic in a single file.
 
 ```html
-<link
-  rel="stylesheet"
-  href="https://cdn.jsdelivr.net/npm/@pelican-identity/vanilla@1.0.2/dist/pelican.css"
-/>
-
 <script src="https://cdn.jsdelivr.net/npm/@pelican-identity/vanilla@1.0.2/dist/index.min.js"></script>
 
 <div id="pelican-auth-root"></div>
@@ -44,7 +39,6 @@ npm install @pelican-identity/vanilla
 
 ```typescript
 import { createPelicanAuth } from "@pelican-identity/vanilla";
-import "@pelican-identity/vanilla/dist/pelican.css";
 
 const cleanup = createPelicanAuth("container-id", {
   publicKey: "...",
@@ -164,11 +158,4 @@ interface IdentityResult {
 **Cause:** The engine might be in `initializing` state or the domain isn't whitelisted.
 **Fix:** Check your Pelican Dashboard and ensure your current domain (including port if applicable) is added to the project whitelist.
 
-### Styles not applying
-
-**Cause:** The CSS file is missing.
-**Fix:** If using NPM, ensure you import `@pelican-identity/vanilla/dist/pelican.css`. If using the CDN `.min.js` version with `injectStyle: true`, this should be automatic.
-
----
-
 **Would you like me to help you create a "Getting Started" guide specifically for the Pelican Dashboard setup to complement this SDK documentation?**

package/dist/index.d.ts

@@ -1,8 +1,187 @@
-export * from "./types/types";
-export { PelicanAuthentication } from "./engine/engine";
-export { CryptoService } from "./utilities/crypto";
-export { StateMachine } from "./utilities/stateMachine";
-export { Transport } from "./utilities/transport";
-export * from "./utilities/storage";
-export { BASEURL } from "./constants";
-//# sourceMappingURL=index.d.ts.map
+type AuthType = "login" | "signup" | "id-verification";
+type PelicanAuthState = "idle" | "initializing" | "awaiting-pair" | "paired" | "awaiting-auth" | "authenticated" | "confirmed" | "error" | "terminated";
+interface PelicanAuthConfig {
+    publicKey: string;
+    projectId: string;
+    authType: AuthType;
+    continuousMode?: boolean;
+    forceQRCode?: boolean;
+}
+type PelicanAuthEventMap = {
+    state: PelicanAuthState;
+    qr: string;
+    deeplink: string;
+    success: IdentityResult;
+    error: Error;
+};
+interface ISocketMessage {
+    type: "confirmed" | "request-passcode" | "client-terminated" | "phone-terminated" | "pair" | "paired" | "phone-auth-success" | "authenticate" | "confirm" | "register";
+    sessionID: string;
+    cipher?: string;
+    nonce?: string;
+    publicKey?: string;
+    url?: string;
+    authType?: AuthType;
+    projectId?: string;
+    grantedAttributes?: {
+        [key: string]: boolean;
+    };
+}
+interface IPhone {
+    id: number;
+    country: string;
+    callingCode: string;
+    number: string;
+    verifiedAt: string;
+    verificationProvider: string;
+}
+interface IEmail {
+    id: number;
+    value: string;
+    verifiedAt: string;
+    verificationProvider: string;
+}
+type IdCardTypes = "national id card" | "passport" | "driver's license" | "residence permit";
+interface IKycData {
+    id: number;
+    status?: "Approved" | "Declined" | "In Review";
+    document_type?: IdCardTypes;
+    document_number?: string;
+    personal_number?: string;
+    date_of_birth?: string | Date;
+    age?: number;
+    expiration_date?: string | Date;
+    date_of_issue?: string | Date;
+    issuing_state?: string;
+    issuing_state_name?: string;
+    first_name?: string;
+    last_name?: string;
+    full_name?: string;
+    gender?: string;
+    address?: string;
+    formatted_address?: string;
+    place_of_birth?: string;
+    marital_status?: string;
+    nationality?: string;
+    liveness_percentage?: number;
+    face_match_percentage?: number;
+    verified_at?: string | Date;
+}
+interface IUserData {
+    first_name?: string;
+    last_name?: string;
+    other_names?: string;
+    email?: IEmail;
+    phone?: IPhone;
+    dob?: string | Date;
+    gender?: "male" | "female" | "other";
+    country?: string;
+    state?: string;
+    city?: string;
+    address?: string;
+    occupation?: string;
+    company?: string;
+    website?: string;
+}
+interface IdentityResult {
+    user_id: string;
+    user_data?: IUserData;
+    id_verification: IKycData;
+    id_downloadurls?: {
+        front_of_card?: string;
+        back_of_card?: string;
+    };
+}
+interface PelicanWebAuthProps extends PelicanAuthConfig {
+    onClose?: () => void;
+    onSuccess: (result: IdentityResult) => void;
+    onError?: (error: Error) => void;
+    buttonComponent?: React.ReactElement;
+    buttonText?: string;
+}
+
+type Listener<T> = (payload: T) => void;
+declare class PelicanAuthentication {
+    private readonly crypto;
+    private readonly stateMachine;
+    private transport?;
+    private sessionId;
+    private sessionKey;
+    private visibilityHandler?;
+    private listeners;
+    private readonly config;
+    constructor(config: PelicanAuthConfig);
+    on<K extends keyof PelicanAuthEventMap>(event: K, cb: Listener<PelicanAuthEventMap[K]>): () => boolean;
+    start(): Promise<void>;
+    stop(): void;
+    private fetchRelayUrl;
+    private emitEntryPoint;
+    private handleMessage;
+    private handleAuthSuccess;
+    private getCachedEntry;
+    private attachVisibilityRecovery;
+    private detachVisibilityRecovery;
+    private terminate;
+    private restartIfContinuous;
+    private resetSession;
+    destroy(): void;
+    private emit;
+    private fail;
+}
+
+interface EncryptedMessage {
+    cipher: string;
+    nonce: string;
+}
+declare class CryptoService {
+    generateSymmetricKey(): string;
+    encryptSymmetric({ plaintext, keyString, }: {
+        plaintext: string;
+        keyString: string;
+    }): EncryptedMessage;
+    decryptSymmetric({ encrypted, keyString, }: {
+        encrypted: EncryptedMessage;
+        keyString: string;
+    }): string | null;
+}
+
+declare class StateMachine {
+    private state;
+    private listeners;
+    get current(): PelicanAuthState;
+    transition(next: PelicanAuthState): void;
+    subscribe(fn: (s: PelicanAuthState) => void): () => boolean;
+}
+
+type TransportHandlers = {
+    onOpen?: () => void;
+    onMessage?: (msg: ISocketMessage) => void;
+    onError?: (err: Event) => void;
+    onClose?: (ev: CloseEvent) => void;
+};
+declare class Transport {
+    private socket?;
+    private handlers;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private isExplicitlyClosed;
+    private url?;
+    constructor(handlers: TransportHandlers);
+    connect(url: string): void;
+    private attemptReconnect;
+    send(payload: ISocketMessage): void;
+    close(): void;
+}
+
+interface AuthSession {
+    sessionId: string;
+    sessionKey: string;
+}
+declare const storeAuthSession: (sessionId: string, sessionKey: string, ttlMs?: number) => void;
+declare const getAuthSession: () => AuthSession | null;
+declare const clearAuthSession: () => void;
+declare const clearAllAuthData: () => void;
+
+declare const BASEURL = "https://identityapi.pelicanidentity.com";
+
+export { type AuthSession, type AuthType, BASEURL, CryptoService, type IEmail, type IKycData, type IPhone, type ISocketMessage, type IUserData, type IdCardTypes, type IdentityResult, type PelicanAuthConfig, type PelicanAuthEventMap, type PelicanAuthState, PelicanAuthentication, type PelicanWebAuthProps, StateMachine, Transport, clearAllAuthData, clearAuthSession, getAuthSession, storeAuthSession };