highperfocused/lume
1
0
Fork 0
mirror of https://github.com/lumehq/lume.git synced 2025-07-07 06:21:41 +02:00
Code Issues Packages Projects Releases Wiki Activity

feat: respect the relay hint

Browse Source
This commit is contained in:
reya
2024-06-07 09:07:33 +07:00
parent 799835a629
commit 04fe0fcec8
4 changed files with 423 additions and 579 deletions
Download Patch File Download Diff File Expand all files Collapse all files

959
packages/system/src/commands.ts
View File

@ -1,590 +1,413 @@
// This file was generated by [tauri-specta](https://github.com/oscartbeaumont/tauri-specta). Do not edit this file manually.
/** user-defined commands **/ // This file was generated by [tauri-specta](https://github.com/oscartbeaumont/tauri-specta). Do not edit this file manually.
export const commands = { /** user-defined commands **/
async getRelays(): Promise<Result<Relays, null>> {
try { export const commands = {
return { status: "ok", data: await TAURI_INVOKE("get_relays") }; async getRelays() : Promise<Result<Relays, null>> {
} catch (e) { try {
if (e instanceof Error) throw e; return { status: "ok", data: await TAURI_INVOKE("get_relays") };
else return { status: "error", error: e as any }; } catch (e) {
} if(e instanceof Error) throw e;
}, else return { status: "error", error: e as any };
async connectRelay(relay: string): Promise<Result<boolean, null>> { }
try { },
return { async connectRelay(relay: string) : Promise<Result<boolean, null>> {
status: "ok", try {
data: await TAURI_INVOKE("connect_relay", { relay }), return { status: "ok", data: await TAURI_INVOKE("connect_relay", { relay }) };
}; } catch (e) {
} catch (e) { if(e instanceof Error) throw e;
if (e instanceof Error) throw e; else return { status: "error", error: e as any };
else return { status: "error", error: e as any }; }
} },
}, async removeRelay(relay: string) : Promise<Result<boolean, null>> {
async removeRelay(relay: string): Promise<Result<boolean, null>> { try {
try { return { status: "ok", data: await TAURI_INVOKE("remove_relay", { relay }) };
return { } catch (e) {
status: "ok", if(e instanceof Error) throw e;
data: await TAURI_INVOKE("remove_relay", { relay }), else return { status: "error", error: e as any };
}; }
} catch (e) { },
if (e instanceof Error) throw e; async getAccounts() : Promise<Result<string[], string>> {
else return { status: "error", error: e as any }; try {
} return { status: "ok", data: await TAURI_INVOKE("get_accounts") };
}, } catch (e) {
async getAccounts(): Promise<Result<string[], string>> { if(e instanceof Error) throw e;
try { else return { status: "error", error: e as any };
return { status: "ok", data: await TAURI_INVOKE("get_accounts") }; }
} catch (e) { },
if (e instanceof Error) throw e; async createAccount() : Promise<Result<Account, null>> {
else return { status: "error", error: e as any }; try {
} return { status: "ok", data: await TAURI_INVOKE("create_account") };
}, } catch (e) {
async createAccount(): Promise<Result<Account, null>> { if(e instanceof Error) throw e;
try { else return { status: "error", error: e as any };
return { status: "ok", data: await TAURI_INVOKE("create_account") }; }
} catch (e) { },
if (e instanceof Error) throw e; async saveAccount(nsec: string, password: string) : Promise<Result<string, string>> {
else return { status: "error", error: e as any }; try {
} return { status: "ok", data: await TAURI_INVOKE("save_account", { nsec, password }) };
}, } catch (e) {
async saveAccount( if(e instanceof Error) throw e;
nsec: string, else return { status: "error", error: e as any };
password: string, }
): Promise<Result<string, string>> { },
try { async getEncryptedKey(npub: string, password: string) : Promise<Result<string, string>> {
return { try {
status: "ok", return { status: "ok", data: await TAURI_INVOKE("get_encrypted_key", { npub, password }) };
data: await TAURI_INVOKE("save_account", { nsec, password }), } catch (e) {
}; if(e instanceof Error) throw e;
} catch (e) { else return { status: "error", error: e as any };
if (e instanceof Error) throw e; }
else return { status: "error", error: e as any }; },
} async connectRemoteAccount(uri: string) : Promise<Result<string, string>> {
}, try {
async getEncryptedKey( return { status: "ok", data: await TAURI_INVOKE("connect_remote_account", { uri }) };
npub: string, } catch (e) {
password: string, if(e instanceof Error) throw e;
): Promise<Result<string, string>> { else return { status: "error", error: e as any };
try { }
return { },
status: "ok", async loadAccount(npub: string, bunker: string | null) : Promise<Result<boolean, string>> {
data: await TAURI_INVOKE("get_encrypted_key", { npub, password }), try {
}; return { status: "ok", data: await TAURI_INVOKE("load_account", { npub, bunker }) };
} catch (e) { } catch (e) {
if (e instanceof Error) throw e; if(e instanceof Error) throw e;
else return { status: "error", error: e as any }; else return { status: "error", error: e as any };
} }
}, },
async connectRemoteAccount(uri: string): Promise<Result<string, string>> { async eventToBech32(id: string, relays: string[]) : Promise<Result<string, null>> {
try { try {
return { return { status: "ok", data: await TAURI_INVOKE("event_to_bech32", { id, relays }) };
status: "ok", } catch (e) {
data: await TAURI_INVOKE("connect_remote_account", { uri }), if(e instanceof Error) throw e;
}; else return { status: "error", error: e as any };
} catch (e) { }
if (e instanceof Error) throw e; },
else return { status: "error", error: e as any }; async userToBech32(key: string, relays: string[]) : Promise<Result<string, null>> {
} try {
}, return { status: "ok", data: await TAURI_INVOKE("user_to_bech32", { key, relays }) };
async loadAccount( } catch (e) {
npub: string, if(e instanceof Error) throw e;
bunker: string | null, else return { status: "error", error: e as any };
): Promise<Result<boolean, string>> { }
try { },
return { async verifyNip05(key: string, nip05: string) : Promise<Result<boolean, string>> {
status: "ok", try {
data: await TAURI_INVOKE("load_account", { npub, bunker }), return { status: "ok", data: await TAURI_INVOKE("verify_nip05", { key, nip05 }) };
}; } catch (e) {
} catch (e) { if(e instanceof Error) throw e;
if (e instanceof Error) throw e; else return { status: "error", error: e as any };
else return { status: "error", error: e as any }; }
} },
}, async getCurrentUserProfile() : Promise<Result<string, string>> {
async eventToBech32( try {
id: string, return { status: "ok", data: await TAURI_INVOKE("get_current_user_profile") };
relays: string[], } catch (e) {
): Promise<Result<string, null>> { if(e instanceof Error) throw e;
try { else return { status: "error", error: e as any };
return { }
status: "ok", },
data: await TAURI_INVOKE("event_to_bech32", { id, relays }), async getProfile(id: string) : Promise<Result<string, string>> {
}; try {
} catch (e) { return { status: "ok", data: await TAURI_INVOKE("get_profile", { id }) };
if (e instanceof Error) throw e; } catch (e) {
else return { status: "error", error: e as any }; if(e instanceof Error) throw e;
} else return { status: "error", error: e as any };
}, }
async userToBech32( },
key: string, async getContactList() : Promise<Result<string[], string>> {
relays: string[], try {
): Promise<Result<string, null>> { return { status: "ok", data: await TAURI_INVOKE("get_contact_list") };
try { } catch (e) {
return { if(e instanceof Error) throw e;
status: "ok", else return { status: "error", error: e as any };
data: await TAURI_INVOKE("user_to_bech32", { key, relays }), }
}; },
} catch (e) { async setContactList(pubkeys: string[]) : Promise<Result<boolean, string>> {
if (e instanceof Error) throw e; try {
else return { status: "error", error: e as any }; return { status: "ok", data: await TAURI_INVOKE("set_contact_list", { pubkeys }) };
} } catch (e) {
}, if(e instanceof Error) throw e;
async verifyNip05( else return { status: "error", error: e as any };
key: string, }
nip05: string, },
): Promise<Result<boolean, string>> { async createProfile(name: string, displayName: string, about: string, picture: string, banner: string, nip05: string, lud16: string, website: string) : Promise<Result<string, string>> {
try { try {
return { return { status: "ok", data: await TAURI_INVOKE("create_profile", { name, displayName, about, picture, banner, nip05, lud16, website }) };
status: "ok", } catch (e) {
data: await TAURI_INVOKE("verify_nip05", { key, nip05 }), if(e instanceof Error) throw e;
}; else return { status: "error", error: e as any };
} catch (e) { }
if (e instanceof Error) throw e; },
else return { status: "error", error: e as any }; async follow(id: string, alias: string | null) : Promise<Result<string, string>> {
} try {
}, return { status: "ok", data: await TAURI_INVOKE("follow", { id, alias }) };
async getCurrentUserProfile(): Promise<Result<string, string>> { } catch (e) {
try { if(e instanceof Error) throw e;
return { else return { status: "error", error: e as any };
status: "ok", }
data: await TAURI_INVOKE("get_current_user_profile"), },
}; async unfollow(id: string) : Promise<Result<string, string>> {
} catch (e) { try {
if (e instanceof Error) throw e; return { status: "ok", data: await TAURI_INVOKE("unfollow", { id }) };
else return { status: "error", error: e as any }; } catch (e) {
} if(e instanceof Error) throw e;
}, else return { status: "error", error: e as any };
async getProfile(id: string): Promise<Result<string, string>> { }
try { },
return { status: "ok", data: await TAURI_INVOKE("get_profile", { id }) }; async getNstore(key: string) : Promise<Result<string, string>> {
} catch (e) { try {
if (e instanceof Error) throw e; return { status: "ok", data: await TAURI_INVOKE("get_nstore", { key }) };
else return { status: "error", error: e as any }; } catch (e) {
} if(e instanceof Error) throw e;
}, else return { status: "error", error: e as any };
async getContactList(): Promise<Result<string[], string>> { }
try { },
return { status: "ok", data: await TAURI_INVOKE("get_contact_list") }; async setNstore(key: string, content: string) : Promise<Result<string, string>> {
} catch (e) { try {
if (e instanceof Error) throw e; return { status: "ok", data: await TAURI_INVOKE("set_nstore", { key, content }) };
else return { status: "error", error: e as any }; } catch (e) {
} if(e instanceof Error) throw e;
}, else return { status: "error", error: e as any };
async setContactList(pubkeys: string[]): Promise<Result<boolean, string>> { }
try { },
return { async setNwc(uri: string) : Promise<Result<boolean, string>> {
status: "ok", try {
data: await TAURI_INVOKE("set_contact_list", { pubkeys }), return { status: "ok", data: await TAURI_INVOKE("set_nwc", { uri }) };
}; } catch (e) {
} catch (e) { if(e instanceof Error) throw e;
if (e instanceof Error) throw e; else return { status: "error", error: e as any };
else return { status: "error", error: e as any }; }
} },
}, async loadNwc() : Promise<Result<boolean, string>> {
async createProfile( try {
name: string, return { status: "ok", data: await TAURI_INVOKE("load_nwc") };
displayName: string, } catch (e) {
about: string, if(e instanceof Error) throw e;
picture: string, else return { status: "error", error: e as any };
banner: string, }
nip05: string, },
lud16: string, async getBalance() : Promise<Result<string, string>> {
website: string, try {
): Promise<Result<string, string>> { return { status: "ok", data: await TAURI_INVOKE("get_balance") };
try { } catch (e) {
return { if(e instanceof Error) throw e;
status: "ok", else return { status: "error", error: e as any };
data: await TAURI_INVOKE("create_profile", { }
name, },
displayName, async zapProfile(id: string, amount: string, message: string) : Promise<Result<boolean, string>> {
about, try {
picture, return { status: "ok", data: await TAURI_INVOKE("zap_profile", { id, amount, message }) };
banner, } catch (e) {
nip05, if(e instanceof Error) throw e;
lud16, else return { status: "error", error: e as any };
website, }
}), },
}; async zapEvent(id: string, amount: string, message: string) : Promise<Result<boolean, string>> {
} catch (e) { try {
if (e instanceof Error) throw e; return { status: "ok", data: await TAURI_INVOKE("zap_event", { id, amount, message }) };
else return { status: "error", error: e as any }; } catch (e) {
} if(e instanceof Error) throw e;
}, else return { status: "error", error: e as any };
async follow( }
id: string, },
alias: string | null, async friendToFriend(npub: string) : Promise<Result<boolean, string>> {
): Promise<Result<string, string>> { try {
try { return { status: "ok", data: await TAURI_INVOKE("friend_to_friend", { npub }) };
return { } catch (e) {
status: "ok", if(e instanceof Error) throw e;
data: await TAURI_INVOKE("follow", { id, alias }), else return { status: "error", error: e as any };
}; }
} catch (e) { },
if (e instanceof Error) throw e; async getNotifications() : Promise<Result<string[], string>> {
else return { status: "error", error: e as any }; try {
} return { status: "ok", data: await TAURI_INVOKE("get_notifications") };
}, } catch (e) {
async unfollow(id: string): Promise<Result<string, string>> { if(e instanceof Error) throw e;
try { else return { status: "error", error: e as any };
return { status: "ok", data: await TAURI_INVOKE("unfollow", { id }) }; }
} catch (e) { },
if (e instanceof Error) throw e; async getEvent(id: string) : Promise<Result<string, string>> {
else return { status: "error", error: e as any }; try {
} return { status: "ok", data: await TAURI_INVOKE("get_event", { id }) };
}, } catch (e) {
async getNstore(key: string): Promise<Result<string, string>> { if(e instanceof Error) throw e;
try { else return { status: "error", error: e as any };
return { status: "ok", data: await TAURI_INVOKE("get_nstore", { key }) }; }
} catch (e) { },
if (e instanceof Error) throw e; async getReplies(id: string) : Promise<Result<string[], string>> {
else return { status: "error", error: e as any }; try {
} return { status: "ok", data: await TAURI_INVOKE("get_replies", { id }) };
}, } catch (e) {
async setNstore( if(e instanceof Error) throw e;
key: string, else return { status: "error", error: e as any };
content: string, }
): Promise<Result<string, string>> { },
try { async getEventsBy(publicKey: string, asOf: string | null) : Promise<Result<string[], string>> {
return { try {
status: "ok", return { status: "ok", data: await TAURI_INVOKE("get_events_by", { publicKey, asOf }) };
data: await TAURI_INVOKE("set_nstore", { key, content }), } catch (e) {
}; if(e instanceof Error) throw e;
} catch (e) { else return { status: "error", error: e as any };
if (e instanceof Error) throw e; }
else return { status: "error", error: e as any }; },
} async getLocalEvents(pubkeys: string[], until: string | null) : Promise<Result<string[], string>> {
}, try {
async setNwc(uri: string): Promise<Result<boolean, string>> { return { status: "ok", data: await TAURI_INVOKE("get_local_events", { pubkeys, until }) };
try { } catch (e) {
return { status: "ok", data: await TAURI_INVOKE("set_nwc", { uri }) }; if(e instanceof Error) throw e;
} catch (e) { else return { status: "error", error: e as any };
if (e instanceof Error) throw e; }
else return { status: "error", error: e as any }; },
} async getGlobalEvents(until: string | null) : Promise<Result<string[], string>> {
}, try {
async loadNwc(): Promise<Result<boolean, string>> { return { status: "ok", data: await TAURI_INVOKE("get_global_events", { until }) };
try { } catch (e) {
return { status: "ok", data: await TAURI_INVOKE("load_nwc") }; if(e instanceof Error) throw e;
} catch (e) { else return { status: "error", error: e as any };
if (e instanceof Error) throw e; }
else return { status: "error", error: e as any }; },
} async getHashtagEvents(hashtags: string[], until: string | null) : Promise<Result<string[], string>> {
}, try {
async getBalance(): Promise<Result<string, string>> { return { status: "ok", data: await TAURI_INVOKE("get_hashtag_events", { hashtags, until }) };
try { } catch (e) {
return { status: "ok", data: await TAURI_INVOKE("get_balance") }; if(e instanceof Error) throw e;
} catch (e) { else return { status: "error", error: e as any };
if (e instanceof Error) throw e; }
else return { status: "error", error: e as any }; },
} async publish(content: string, tags: string[][]) : Promise<Result<string, string>> {
}, try {
async zapProfile( return { status: "ok", data: await TAURI_INVOKE("publish", { content, tags }) };
id: string, } catch (e) {
amount: string, if(e instanceof Error) throw e;
message: string, else return { status: "error", error: e as any };
): Promise<Result<boolean, string>> { }
try { },
return { async repost(raw: string) : Promise<Result<string, string>> {
status: "ok", try {
data: await TAURI_INVOKE("zap_profile", { id, amount, message }), return { status: "ok", data: await TAURI_INVOKE("repost", { raw }) };
}; } catch (e) {
} catch (e) { if(e instanceof Error) throw e;
if (e instanceof Error) throw e; else return { status: "error", error: e as any };
else return { status: "error", error: e as any }; }
} },
}, async showInFolder(path: string) : Promise<void> {
async zapEvent( await TAURI_INVOKE("show_in_folder", { path });
id: string, },
amount: string, async createColumn(label: string, x: number, y: number, width: number, height: number, url: string) : Promise<Result<string, string>> {
message: string, try {
): Promise<Result<boolean, string>> { return { status: "ok", data: await TAURI_INVOKE("create_column", { label, x, y, width, height, url }) };
try { } catch (e) {
return { if(e instanceof Error) throw e;
status: "ok", else return { status: "error", error: e as any };
data: await TAURI_INVOKE("zap_event", { id, amount, message }), }
}; },
} catch (e) { async closeColumn(label: string) : Promise<Result<boolean, null>> {
if (e instanceof Error) throw e; try {
else return { status: "error", error: e as any }; return { status: "ok", data: await TAURI_INVOKE("close_column", { label }) };
} } catch (e) {
}, if(e instanceof Error) throw e;
async friendToFriend(npub: string): Promise<Result<boolean, string>> { else return { status: "error", error: e as any };
try { }
return { },
status: "ok", async repositionColumn(label: string, x: number, y: number) : Promise<Result<null, string>> {
data: await TAURI_INVOKE("friend_to_friend", { npub }), try {
}; return { status: "ok", data: await TAURI_INVOKE("reposition_column", { label, x, y }) };
} catch (e) { } catch (e) {
if (e instanceof Error) throw e; if(e instanceof Error) throw e;
else return { status: "error", error: e as any }; else return { status: "error", error: e as any };
} }
}, },
async getNotifications(): Promise<Result<string[], string>> { async resizeColumn(label: string, width: number, height: number) : Promise<Result<null, string>> {
try { try {
return { status: "ok", data: await TAURI_INVOKE("get_notifications") }; return { status: "ok", data: await TAURI_INVOKE("resize_column", { label, width, height }) };
} catch (e) { } catch (e) {
if (e instanceof Error) throw e; if(e instanceof Error) throw e;
else return { status: "error", error: e as any }; else return { status: "error", error: e as any };
} }
}, },
async getEvent(id: string): Promise<Result<string, string>> { async openWindow(label: string, title: string, url: string, width: number, height: number) : Promise<Result<null, string>> {
try { try {
return { status: "ok", data: await TAURI_INVOKE("get_event", { id }) }; return { status: "ok", data: await TAURI_INVOKE("open_window", { label, title, url, width, height }) };
} catch (e) { } catch (e) {
if (e instanceof Error) throw e; if(e instanceof Error) throw e;
else return { status: "error", error: e as any }; else return { status: "error", error: e as any };
} }
}, },
async getReplies(id: string): Promise<Result<string[], string>> { async setBadge(count: number) : Promise<void> {
try { await TAURI_INVOKE("set_badge", { count });
return { status: "ok", data: await TAURI_INVOKE("get_replies", { id }) }; }
} catch (e) { }
if (e instanceof Error) throw e;
else return { status: "error", error: e as any }; /** user-defined events **/
}
},
async getEventsBy(
publicKey: string, /** user-defined statics **/
asOf: string | null,
): Promise<Result<string[], string>> {
try {
return {
status: "ok",
data: await TAURI_INVOKE("get_events_by", { publicKey, asOf }),
};
} catch (e) {
if (e instanceof Error) throw e;
else return { status: "error", error: e as any };
}
},
async getLocalEvents(
pubkeys: string[],
until: string | null,
): Promise<Result<string[], string>> {
try {
return {
status: "ok",
data: await TAURI_INVOKE("get_local_events", { pubkeys, until }),
};
} catch (e) {
if (e instanceof Error) throw e;
else return { status: "error", error: e as any };
}
},
async getGlobalEvents(
until: string | null,
): Promise<Result<string[], string>> {
try {
return {
status: "ok",
data: await TAURI_INVOKE("get_global_events", { until }),
};
} catch (e) {
if (e instanceof Error) throw e;
else return { status: "error", error: e as any };
}
},
async getHashtagEvents(
hashtags: string[],
until: string | null,
): Promise<Result<string[], string>> {
try {
return {
status: "ok",
data: await TAURI_INVOKE("get_hashtag_events", { hashtags, until }),
};
} catch (e) {
if (e instanceof Error) throw e;
else return { status: "error", error: e as any };
}
},
async publish(
content: string,
tags: string[][],
): Promise<Result<string, string>> {
try {
return {
status: "ok",
data: await TAURI_INVOKE("publish", { content, tags }),
};
} catch (e) {
if (e instanceof Error) throw e;
else return { status: "error", error: e as any };
}
},
async repost(raw: string): Promise<Result<string, string>> {
try {
return { status: "ok", data: await TAURI_INVOKE("repost", { raw }) };
} catch (e) {
if (e instanceof Error) throw e;
else return { status: "error", error: e as any };
}
},
async showInFolder(path: string): Promise<void> {
await TAURI_INVOKE("show_in_folder", { path });
},
async createColumn(
label: string,
x: number,
y: number,
width: number,
height: number,
url: string,
): Promise<Result<string, string>> {
try {
return {
status: "ok",
data: await TAURI_INVOKE("create_column", {
label,
x,
y,
width,
height,
url,
}),
};
} catch (e) {
if (e instanceof Error) throw e;
else return { status: "error", error: e as any };
}
},
async closeColumn(label: string): Promise<Result<boolean, null>> {
try {
return {
status: "ok",
data: await TAURI_INVOKE("close_column", { label }),
};
} catch (e) {
if (e instanceof Error) throw e;
else return { status: "error", error: e as any };
}
},
async repositionColumn(
label: string,
x: number,
y: number,
): Promise<Result<null, string>> {
try {
return {
status: "ok",
data: await TAURI_INVOKE("reposition_column", { label, x, y }),
};
} catch (e) {
if (e instanceof Error) throw e;
else return { status: "error", error: e as any };
}
},
async resizeColumn(
label: string,
width: number,
height: number,
): Promise<Result<null, string>> {
try {
return {
status: "ok",
data: await TAURI_INVOKE("resize_column", { label, width, height }),
};
} catch (e) {
if (e instanceof Error) throw e;
else return { status: "error", error: e as any };
}
},
async openWindow(
label: string,
title: string,
url: string,
width: number,
height: number,
): Promise<Result<null, string>> {
try {
return {
status: "ok",
data: await TAURI_INVOKE("open_window", {
label,
title,
url,
width,
height,
}),
};
} catch (e) {
if (e instanceof Error) throw e;
else return { status: "error", error: e as any };
}
},
async setBadge(count: number): Promise<void> {
await TAURI_INVOKE("set_badge", { count });
},
};
/** user-defined events **/
/** user-defined statics **/
/** user-defined types **/ /** user-defined types **/
export type Account = { npub: string; nsec: string }; export type Account = { npub: string; nsec: string }
export type Relays = { export type Relays = { connected: string[]; read: string[] | null; write: string[] | null; both: string[] | null }
connected: string[];
read: string[] | null;
write: string[] | null;
both: string[] | null;
};
/** tauri-specta globals **/ /** tauri-specta globals **/
import { invoke as TAURI_INVOKE } from "@tauri-apps/api/core"; import { invoke as TAURI_INVOKE } from "@tauri-apps/api/core";
import * as TAURI_API_EVENT from "@tauri-apps/api/event"; import * as TAURI_API_EVENT from "@tauri-apps/api/event";
import { type WebviewWindow as __WebviewWindow__ } from "@tauri-apps/api/webviewWindow"; import { type WebviewWindow as __WebviewWindow__ } from "@tauri-apps/api/webviewWindow";
type __EventObj__<T> = { type __EventObj__<T> = {
listen: ( listen: (
cb: TAURI_API_EVENT.EventCallback<T>, cb: TAURI_API_EVENT.EventCallback<T>
) => ReturnType<typeof TAURI_API_EVENT.listen<T>>; ) => ReturnType<typeof TAURI_API_EVENT.listen<T>>;
once: ( once: (
cb: TAURI_API_EVENT.EventCallback<T>, cb: TAURI_API_EVENT.EventCallback<T>
) => ReturnType<typeof TAURI_API_EVENT.once<T>>; ) => ReturnType<typeof TAURI_API_EVENT.once<T>>;
emit: T extends null emit: T extends null
? (payload?: T) => ReturnType<typeof TAURI_API_EVENT.emit> ? (payload?: T) => ReturnType<typeof TAURI_API_EVENT.emit>
: (payload: T) => ReturnType<typeof TAURI_API_EVENT.emit>; : (payload: T) => ReturnType<typeof TAURI_API_EVENT.emit>;
}; };
export type Result<T, E> = export type Result<T, E> =
| { status: "ok"; data: T } | { status: "ok"; data: T }
| { status: "error"; error: E }; | { status: "error"; error: E };
function __makeEvents__<T extends Record<string, any>>( function __makeEvents__<T extends Record<string, any>>(
mappings: Record<keyof T, string>, mappings: Record<keyof T, string>
) { ) {
return new Proxy( return new Proxy(
{} as unknown as { {} as unknown as {
[K in keyof T]: __EventObj__<T[K]> & { [K in keyof T]: __EventObj__<T[K]> & {
(handle: __WebviewWindow__): __EventObj__<T[K]>; (handle: __WebviewWindow__): __EventObj__<T[K]>;
}; };
}, },
{ {
get: (_, event) => { get: (_, event) => {
const name = mappings[event as keyof T]; const name = mappings[event as keyof T];
return new Proxy((() => {}) as any, { return new Proxy((() => {}) as any, {
apply: (_, __, [window]: [__WebviewWindow__]) => ({ apply: (_, __, [window]: [__WebviewWindow__]) => ({
listen: (arg: any) => window.listen(name, arg), listen: (arg: any) => window.listen(name, arg),
once: (arg: any) => window.once(name, arg), once: (arg: any) => window.once(name, arg),
emit: (arg: any) => window.emit(name, arg), emit: (arg: any) => window.emit(name, arg),
}), }),
get: (_, command: keyof __EventObj__<any>) => { get: (_, command: keyof __EventObj__<any>) => {
switch (command) { switch (command) {
case "listen": case "listen":
return (arg: any) => TAURI_API_EVENT.listen(name, arg); return (arg: any) => TAURI_API_EVENT.listen(name, arg);
case "once": case "once":
return (arg: any) => TAURI_API_EVENT.once(name, arg); return (arg: any) => TAURI_API_EVENT.once(name, arg);
case "emit": case "emit":
return (arg: any) => TAURI_API_EVENT.emit(name, arg); return (arg: any) => TAURI_API_EVENT.emit(name, arg);
} }
}, },
}); });
}, },
}, }
); );
} }

28
packages/system/src/event.ts
View File

@ -22,7 +22,7 @@ export class LumeEvent {
return this.tags.filter((tag) => tag[0] === "p").map((tag) => tag[1]); return this.tags.filter((tag) => tag[0] === "p").map((tag) => tag[1]);
} }
static getEventThread(tags: string[][], gossip?: boolean) { static getEventThread(tags: string[][], gossip = true) {
let root: string = null; let root: string = null;
let reply: string = null; let reply: string = null;
@ -30,14 +30,22 @@ export class LumeEvent {
const events = tags.filter((el) => el[0] === "e" && el[3] !== "mention"); const events = tags.filter((el) => el[0] === "e" && el[3] !== "mention");
if (gossip) { if (gossip) {
const relays = tags.filter((el) => el[0] === "e" && el[2]?.length); const relays = tags
.filter((el) => el[0] === "e" && el[2]?.length)
.map((tag) => tag[2]);
if (relays.length >= 1) { if (relays.length >= 1) {
for (const relay of relays) { for (const relay of relays) {
if (relay[2]?.length) try {
commands if (relay.length) {
.connectRelay(relay[2]) const url = new URL(relay);
.then(() => console.log("[gossip]: ", relay[2])); commands
.connectRelay(url.toString())
.then(() => console.log("[relay hint]: ", url));
}
} catch (e) {
console.log("[relay hint] error: ", relay);
}
} }
} }
} }
@ -82,6 +90,14 @@ export class LumeEvent {
for (const tag of tags) { for (const tag of tags) {
const rootIndex = events.findIndex((el) => el.id === tag[1]); const rootIndex = events.findIndex((el) => el.id === tag[1]);
// Relay Hint
if (tag[2]?.length) {
const url = new URL(tag[2]);
commands
.connectRelay(url.toString())
.then(() => console.log("[relay hint]: ", url));
}
if (rootIndex !== -1) { if (rootIndex !== -1) {
const rootEvent = events[rootIndex]; const rootEvent = events[rootIndex];

5
src-tauri/src/nostr/event.rs
View File

@ -13,9 +13,8 @@ pub async fn get_event(id: &str, state: State<'_, Nostr>) -> Result<String, Stri
Nip19::Event(event) => { Nip19::Event(event) => {
let relays = event.relays; let relays = event.relays;
for relay in relays.into_iter() { for relay in relays.into_iter() {
let url = Url::from_str(&relay).unwrap(); let _ = client.add_relay(&relay).await.unwrap_or_default();
let _ = client.add_relay(&url).await.unwrap_or_default(); client.connect_relay(&relay).await.unwrap_or_default();
client.connect_relay(&url).await.unwrap_or_default();
} }
Some(event.event_id) Some(event.event_id)
} }

10
src-tauri/src/nostr/metadata.rs
View File

@ -4,7 +4,6 @@ use keyring::Entry;
use nostr_sdk::prelude::*; use nostr_sdk::prelude::*;
use std::{str::FromStr, time::Duration}; use std::{str::FromStr, time::Duration};
use tauri::State; use tauri::State;
use url::Url;
#[tauri::command] #[tauri::command]
#[specta::specta] #[specta::specta]
@ -43,7 +42,14 @@ pub async fn get_profile(id: &str, state: State<'_, Nostr>) -> Result<String, St
let public_key: Option<PublicKey> = match Nip19::from_bech32(id) { let public_key: Option<PublicKey> = match Nip19::from_bech32(id) {
Ok(val) => match val { Ok(val) => match val {
Nip19::Pubkey(pubkey) => Some(pubkey), Nip19::Pubkey(pubkey) => Some(pubkey),
Nip19::Profile(profile) => Some(profile.public_key), Nip19::Profile(profile) => {
let relays = profile.relays;
for relay in relays.into_iter() {
let _ = client.add_relay(&relay).await.unwrap_or_default();
client.connect_relay(&relay).await.unwrap_or_default();
}
Some(profile.public_key)
}
_ => None, _ => None,
}, },
Err(_) => match PublicKey::from_str(id) { Err(_) => match PublicKey::from_str(id) {