@konemono/nostr-login 1.7.11

package/dist/modules/AuthNostrService.d.ts

@@ -0,0 +1,84 @@
+import { ConnectionString, Info } from 'nostr-login-components';
+import { NostrParams } from './';
+import { EventEmitter } from 'tseep';
+import { Signer } from './Nostr';
+declare class AuthNostrService extends EventEmitter implements Signer {
+    private ndk;
+    private profileNdk;
+    private signer;
+    private localSigner;
+    private params;
+    private signerPromise?;
+    private signerErrCallback?;
+    private readyPromise?;
+    private readyCallback?;
+    private nip44Codec;
+    private nostrConnectKey;
+    private nostrConnectSecret;
+    private iframe?;
+    private starterReady?;
+    nip04: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
+    };
+    nip44: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
+    };
+    constructor(params: NostrParams);
+    isIframe(): boolean;
+    waitReady(): Promise<void>;
+    cancelNostrConnect(): void;
+    nostrConnect(relay?: string, { domain, link, iframeUrl, importConnect, }?: {
+        domain?: string;
+        link?: string;
+        importConnect?: boolean;
+        iframeUrl?: string;
+    }): Promise<Info>;
+    createNostrConnect(relay?: string): Promise<string>;
+    getNostrConnectServices(): Promise<[string, ConnectionString[]]>;
+    localSignup(name: string, sk?: string): Promise<void>;
+    setLocal(info: Info, signup?: boolean): Promise<void>;
+    prepareImportUrl(url: string): string;
+    importAndConnect(cs: ConnectionString): Promise<void>;
+    setReadOnly(pubkey: string): void;
+    setExtension(pubkey: string): void;
+    setOTP(pubkey: string, data: string): void;
+    setConnect(info: Info): Promise<void>;
+    createAccount(nip05: string): Promise<{
+        bunkerUrl: string;
+        sk: string | undefined;
+    }>;
+    private releaseSigner;
+    logout(keepSigner?: boolean): Promise<void>;
+    private setUserInfo;
+    exportKeys(): "" | `nsec1${string}`;
+    private onAuth;
+    private createIframe;
+    sendNeedAuth(): Promise<void>;
+    isAuthing(): boolean;
+    startAuth(): Promise<void>;
+    endAuth(): Promise<void>;
+    resetAuth(): void;
+    private listen;
+    connect(info: Info, perms?: string): Promise<void>;
+    initSigner(info: Info, { listen, connect, eventToAddAccount }?: {
+        listen?: boolean | undefined;
+        connect?: boolean | undefined;
+        eventToAddAccount?: boolean | undefined;
+    }): Promise<void>;
+    authNip46(type: 'login' | 'signup', { name, bunkerUrl, sk, domain, iframeUrl }: {
+        name: string;
+        bunkerUrl: string;
+        sk?: string;
+        domain?: string;
+        iframeUrl?: string;
+    }): Promise<void>;
+    signEvent(event: any): Promise<any>;
+    private codec_call;
+    encrypt04(pubkey: string, plaintext: string): Promise<string>;
+    decrypt04(pubkey: string, ciphertext: string): Promise<string>;
+    encrypt44(pubkey: string, plaintext: string): Promise<string>;
+    decrypt44(pubkey: string, ciphertext: string): Promise<string>;
+}
+export default AuthNostrService;

package/dist/modules/BannerManager.d.ts

@@ -0,0 +1,20 @@
+import { NostrLoginOptions } from '../types';
+import { NostrParams } from '.';
+import { Info } from 'nostr-login-components';
+import { EventEmitter } from 'tseep';
+declare class BannerManager extends EventEmitter {
+    private banner;
+    private iframeReady?;
+    private params;
+    constructor(params: NostrParams);
+    onAuthUrl(url: string, iframeUrl: string): void;
+    onIframeRestart(iframeUrl: string): void;
+    onUserInfo(info: Info | null): void;
+    onCallTimeout(): void;
+    onCallStart(): void;
+    onCallEnd(): Promise<void>;
+    onUpdateAccounts(accounts: Info[]): void;
+    onDarkMode(dark: boolean): void;
+    launchAuthBanner(opt: NostrLoginOptions): void;
+}
+export default BannerManager;

package/dist/modules/ModalManager.d.ts

@@ -0,0 +1,25 @@
+import { NostrLoginOptions } from '../types';
+import { AuthNostrService, NostrExtensionService, NostrParams } from '.';
+import { EventEmitter } from 'tseep';
+import { Info, RecentType } from 'nostr-login-components';
+declare class ModalManager extends EventEmitter {
+    private modal;
+    private params;
+    private extensionService;
+    private authNostrService;
+    private launcherPromise?;
+    private accounts;
+    private recents;
+    private opt?;
+    constructor(params: NostrParams, authNostrService: AuthNostrService, extensionManager: NostrExtensionService);
+    waitReady(): Promise<void>;
+    launch(opt: NostrLoginOptions): Promise<void>;
+    showIframeUrl(url: string): Promise<void>;
+    connectModals(defaultOpt: NostrLoginOptions): void;
+    onAuthUrl(url: string): void;
+    onIframeUrl(url: string): void;
+    onCallEnd(): void;
+    onUpdateAccounts(accounts: Info[], recents: RecentType[]): void;
+    onDarkMode(dark: boolean): void;
+}
+export default ModalManager;

package/dist/modules/Nip46.d.ts

@@ -0,0 +1,56 @@
+import NDK, { NDKEvent, NDKFilter, NDKNip46Signer, NDKNostrRpc, NDKRpcRequest, NDKRpcResponse, NDKSubscription } from '@nostr-dev-kit/ndk';
+import { PrivateKeySigner } from './Signer';
+declare class NostrRpc extends NDKNostrRpc {
+    protected _ndk: NDK;
+    protected _signer: PrivateKeySigner;
+    protected requests: Set<string>;
+    private sub?;
+    protected _useNip44: boolean;
+    constructor(ndk: NDK, signer: PrivateKeySigner);
+    subscribe(filter: NDKFilter): Promise<NDKSubscription>;
+    stop(): void;
+    setUseNip44(useNip44: boolean): void;
+    private isNip04;
+    parseEvent(event: NDKEvent): Promise<NDKRpcRequest | NDKRpcResponse>;
+    parseNostrConnectReply(reply: any, secret: string): Promise<string>;
+    listen(nostrConnectSecret: string): Promise<string>;
+    connect(pubkey: string, token?: string, perms?: string): Promise<void>;
+    protected getId(): string;
+    sendRequest(remotePubkey: string, method: string, params?: string[], kind?: number, cb?: (res: NDKRpcResponse) => void): Promise<NDKRpcResponse>;
+    protected setResponseHandler(id: string, cb?: (res: NDKRpcResponse) => void): Promise<NDKRpcResponse>;
+    protected createRequestEvent(id: string, remotePubkey: string, method: string, params?: string[], kind?: number): Promise<NDKEvent>;
+}
+export declare class IframeNostrRpc extends NostrRpc {
+    private peerOrigin?;
+    private iframePort?;
+    private iframeRequests;
+    constructor(ndk: NDK, localSigner: PrivateKeySigner, iframePeerOrigin?: string);
+    subscribe(filter: NDKFilter): Promise<NDKSubscription>;
+    setWorkerIframePort(port: MessagePort): void;
+    sendRequest(remotePubkey: string, method: string, params?: string[], kind?: number, cb?: (res: NDKRpcResponse) => void): Promise<NDKRpcResponse>;
+}
+export declare class ReadyListener {
+    origin: string;
+    messages: string[];
+    promise: Promise<any>;
+    constructor(messages: string[], origin: string);
+    wait(): Promise<any>;
+}
+export declare class Nip46Signer extends NDKNip46Signer {
+    private _userPubkey;
+    private _rpc;
+    constructor(ndk: NDK, localSigner: PrivateKeySigner, signerPubkey: string, iframeOrigin?: string);
+    get userPubkey(): string;
+    private setSignerPubkey;
+    initUserPubkey(hintPubkey?: string): Promise<void>;
+    listen(nostrConnectSecret: string): Promise<void>;
+    connect(token?: string, perms?: string): Promise<void>;
+    setListenReply(reply: any, nostrConnectSecret: string): Promise<void>;
+    createAccount2({ bunkerPubkey, name, domain, perms }: {
+        bunkerPubkey: string;
+        name: string;
+        domain: string;
+        perms?: string;
+    }): Promise<string>;
+}
+export {};

package/dist/modules/Nostr.d.ts

@@ -0,0 +1,34 @@
+import { Info } from 'nostr-login-components';
+export interface Signer {
+    signEvent: (event: any) => Promise<any>;
+    nip04: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
+    };
+    nip44: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
+    };
+}
+export interface NostrObjectParams {
+    waitReady(): Promise<void>;
+    getUserInfo(): Info | null;
+    launch(): Promise<void>;
+    getSigner(): Signer;
+    wait<T>(cb: () => Promise<T>): Promise<T>;
+}
+declare class Nostr {
+    #private;
+    private nip04;
+    private nip44;
+    constructor(params: NostrObjectParams);
+    private ensureAuth;
+    getPublicKey(): Promise<string>;
+    signEvent(event: any): Promise<any>;
+    getRelays(): Promise<{}>;
+    encrypt04(pubkey: string, plaintext: string): Promise<string>;
+    decrypt04(pubkey: string, ciphertext: string): Promise<string>;
+    encrypt44(pubkey: string, plaintext: string): Promise<string>;
+    decrypt44(pubkey: string, ciphertext: string): Promise<string>;
+}
+export default Nostr;

package/dist/modules/NostrExtensionService.d.ts

@@ -0,0 +1,17 @@
+import { Nostr, NostrParams } from './';
+import { EventEmitter } from 'tseep';
+declare class NostrExtensionService extends EventEmitter {
+    private params;
+    private nostrExtension;
+    constructor(params: NostrParams);
+    startCheckingExtension(nostr: Nostr): void;
+    private checkExtension;
+    private initExtension;
+    private setExtensionReadPubkey;
+    trySetExtensionForPubkey(expectedPubkey: string): Promise<void>;
+    setExtension(): Promise<void>;
+    unsetExtension(nostr: Nostr): void;
+    getExtension(): any;
+    hasExtension(): boolean;
+}
+export default NostrExtensionService;

package/dist/modules/NostrParams.d.ts

@@ -0,0 +1,8 @@
+import { Info } from 'nostr-login-components';
+import { NostrLoginOptions } from '../types';
+declare class NostrParams {
+    userInfo: Info | null;
+    optionsModal: NostrLoginOptions;
+    constructor();
+}
+export default NostrParams;

package/dist/modules/Popup.d.ts

@@ -0,0 +1,7 @@
+declare class Popup {
+    private popup;
+    constructor();
+    openPopup(url: string): void;
+    closePopup(): void;
+}
+export default Popup;

package/dist/modules/ProcessManager.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from 'tseep';
+declare class ProcessManager extends EventEmitter {
+    private callCount;
+    private callTimer;
+    constructor();
+    onAuthUrl(): void;
+    onIframeUrl(): void;
+    wait<T>(cb: () => Promise<T>): Promise<T>;
+}
+export default ProcessManager;

package/dist/modules/Signer.d.ts

@@ -0,0 +1,9 @@
+import { NDKPrivateKeySigner, NDKUser } from '@nostr-dev-kit/ndk';
+export declare class PrivateKeySigner extends NDKPrivateKeySigner {
+    private nip44;
+    private _pubkey;
+    constructor(privateKey: string);
+    get pubkey(): string;
+    encryptNip44(recipient: NDKUser, value: string): Promise<string>;
+    decryptNip44(sender: NDKUser, value: string): Promise<string>;
+}

package/dist/modules/index.d.ts

@@ -0,0 +1,8 @@
+export { default as BannerManager } from './BannerManager';
+export { default as AuthNostrService } from './AuthNostrService';
+export { default as ModalManager } from './ModalManager';
+export { default as Nostr } from './Nostr';
+export { default as NostrExtensionService } from './NostrExtensionService';
+export { default as NostrParams } from './NostrParams';
+export { default as Popup } from './Popup';
+export { default as ProcessManager } from './ProcessManager';

package/dist/types.d.ts

@@ -0,0 +1,72 @@
+import { Info, AuthMethod, ConnectionString, RecentType, BannerNotify } from 'nostr-login-components';
+export interface NostrLoginAuthOptions {
+    localNsec?: string;
+    relays?: string[];
+    type: 'login' | 'signup' | 'logout';
+    method?: AuthMethod;
+    pubkey?: string;
+    otpData?: string;
+    name?: string;
+}
+export type StartScreens = 'welcome' | 'welcome-login' | 'welcome-signup' | 'signup' | 'local-signup' | 'login' | 'otp' | 'connect' | 'login-bunker-url' | 'login-read-only' | 'connection-string' | 'switch-account' | 'import';
+export interface NostrLoginOptions {
+    theme?: string;
+    startScreen?: StartScreens;
+    bunkers?: string;
+    onAuth?: (npub: string, options: NostrLoginAuthOptions) => void;
+    perms?: string;
+    darkMode?: boolean;
+    noBanner?: boolean;
+    devOverrideBunkerOrigin?: string;
+    localSignup?: boolean;
+    methods?: AuthMethod[];
+    otpRequestUrl?: string;
+    otpReplyUrl?: string;
+    title?: string;
+    description?: string;
+    signupRelays?: string;
+    outboxRelays?: string[];
+    dev?: boolean;
+    signupNstart?: boolean;
+    followNpubs?: string;
+    customNostrConnect?: boolean;
+}
+export interface IBanner {
+    userInfo?: Info | null;
+    titleBanner?: string;
+    isLoading?: boolean;
+    listNotifies?: string[];
+    accounts?: Info[];
+    isOpen?: boolean;
+    darkMode?: boolean;
+    notify?: BannerNotify;
+}
+export type TypeBanner = IBanner & HTMLElement;
+export interface IModal {
+    authUrl?: string;
+    iframeUrl?: string;
+    isLoading?: boolean;
+    isOTP?: boolean;
+    isLoadingExtension?: boolean;
+    localSignup?: boolean;
+    signupNjump?: boolean;
+    njumpIframe?: string;
+    authMethods?: AuthMethod[];
+    hasExtension?: boolean;
+    hasOTP?: boolean;
+    error?: string;
+    signupNameIsAvailable?: string | boolean;
+    loginIsGood?: string | boolean;
+    recents?: RecentType[];
+    accounts?: Info[];
+    darkMode?: boolean;
+    welcomeTitle?: string;
+    welcomeDescription?: string;
+    connectionString?: string;
+    connectionStringServices?: ConnectionString[];
+}
+export type TypeModal = IModal & HTMLElement;
+export interface Response {
+    result?: string;
+    error?: string;
+}