2023-06-30 14:05:57 +00:00
|
|
|
import { getProfileEvent, getProfilesByName, saveProfile } from "../features/profile.ts";
|
|
|
|
|
|
|
|
import { App } from "./app.tsx";
|
|
|
|
import { getAllUsersInformation, getGroupOf, ProfilesSyncer, UserInfo } from "./contact-list.ts";
|
2023-07-09 07:06:13 +00:00
|
|
|
|
2023-06-30 14:05:57 +00:00
|
|
|
import * as csp from "https://raw.githubusercontent.com/BlowaterNostr/csp/master/csp.ts";
|
|
|
|
import { Database } from "../database.ts";
|
|
|
|
import { convertEventsToChatMessages } from "./dm.ts";
|
|
|
|
|
|
|
|
import { get_Kind4_Events_Between, sendDMandImages, sendSocialPost } from "../features/dm.ts";
|
|
|
|
import { notify } from "./notification.ts";
|
|
|
|
import { EventBus, EventEmitter } from "../event-bus.ts";
|
|
|
|
import { ContactUpdate } from "./contact-list.tsx";
|
|
|
|
import { MyProfileUpdate } from "./edit-profile.tsx";
|
|
|
|
import { EditorEvent, new_DM_EditorModel } from "./editor.tsx";
|
|
|
|
import { DirectMessagePanelUpdate } from "./message-panel.tsx";
|
|
|
|
import { NavigationUpdate } from "./nav.tsx";
|
|
|
|
import { Model } from "./app_model.ts";
|
|
|
|
import { SearchUpdate, SelectProfile } from "./search_model.ts";
|
|
|
|
import { LamportTime } from "../time.ts";
|
|
|
|
import { PublicKey } from "https://raw.githubusercontent.com/BlowaterNostr/nostr.ts/main/key.ts";
|
|
|
|
import {
|
|
|
|
NostrAccountContext,
|
|
|
|
NostrEvent,
|
|
|
|
NostrKind,
|
|
|
|
prepareCustomAppDataEvent,
|
|
|
|
} from "https://raw.githubusercontent.com/BlowaterNostr/nostr.ts/main/nostr.ts";
|
|
|
|
import { ConnectionPool } from "https://raw.githubusercontent.com/BlowaterNostr/nostr.ts/main/relay.ts";
|
2023-07-09 07:06:13 +00:00
|
|
|
import { SignInEvent, signInWithExtension, signInWithPrivateKey } from "./signIn.tsx";
|
2023-06-30 14:05:57 +00:00
|
|
|
import { computeThreads, getTags, PinContact, UnpinContact } from "../nostr.ts";
|
|
|
|
import { MessageThread } from "./dm.tsx";
|
|
|
|
|
|
|
|
export type UI_Interaction_Event =
|
|
|
|
| RemoveRelayButtonClicked
|
|
|
|
| AddRelayButtonClicked
|
|
|
|
| AddRelayInputChange
|
|
|
|
| SearchUpdate
|
|
|
|
| ContactUpdate
|
|
|
|
| EditorEvent
|
|
|
|
| NavigationUpdate
|
|
|
|
| DirectMessagePanelUpdate
|
|
|
|
| BackToContactList
|
|
|
|
| MyProfileUpdate
|
|
|
|
| PinContact
|
|
|
|
| UnpinContact
|
|
|
|
| SignInEvent;
|
|
|
|
|
|
|
|
type RemoveRelayButtonClicked = {
|
|
|
|
type: "RemoveRelayButtonClicked";
|
|
|
|
url: string;
|
|
|
|
};
|
|
|
|
type AddRelayButtonClicked = {
|
|
|
|
type: "AddRelayButtonClicked";
|
|
|
|
url: string;
|
|
|
|
};
|
|
|
|
type AddRelayInputChange = {
|
|
|
|
type: "AddRelayInputChange";
|
|
|
|
url: string;
|
|
|
|
};
|
|
|
|
type BackToContactList = {
|
|
|
|
type: "BackToContactList";
|
|
|
|
};
|
|
|
|
export type AppEventBus = EventBus<UI_Interaction_Event>;
|
|
|
|
|
|
|
|
/////////////////////
|
|
|
|
// UI Interfaction //
|
|
|
|
/////////////////////
|
|
|
|
export async function* UI_Interaction_Update(
|
|
|
|
app: App,
|
|
|
|
profileSyncer: ProfilesSyncer,
|
|
|
|
lamport: LamportTime,
|
|
|
|
) {
|
|
|
|
const events = app.eventBus.onChange();
|
|
|
|
for await (const event of events) {
|
|
|
|
console.log(event);
|
2023-07-09 07:06:13 +00:00
|
|
|
switch (event.type) {
|
|
|
|
case "editSignInPrivateKey":
|
|
|
|
app.model.signIn.privateKey = event.privateKey;
|
|
|
|
break;
|
|
|
|
case "createNewAccount":
|
|
|
|
app.model.signIn.state = "newAccount";
|
|
|
|
break;
|
|
|
|
case "backToSignInPage":
|
|
|
|
app.model.signIn.state = "enterPrivateKey";
|
|
|
|
break;
|
|
|
|
case "signin":
|
|
|
|
let ctx;
|
|
|
|
if (event.privateKey) {
|
|
|
|
ctx = signInWithPrivateKey(event.privateKey);
|
|
|
|
} else {
|
|
|
|
const ctx2 = await signInWithExtension();
|
|
|
|
console.log(ctx2);
|
|
|
|
if (typeof ctx2 == "string") {
|
|
|
|
app.model.signIn.warningString = ctx2;
|
|
|
|
} else if (ctx2 instanceof Error) {
|
|
|
|
app.model.signIn.warningString = ctx2.message;
|
|
|
|
} else {
|
|
|
|
ctx = ctx2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (ctx) {
|
|
|
|
console.log("sign in as", ctx.publicKey.bech32());
|
|
|
|
const err = await app.initApp(ctx);
|
|
|
|
if (err instanceof Error) {
|
|
|
|
console.error(err.message);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
console.error("failed to sign in");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2023-06-30 14:05:57 +00:00
|
|
|
//
|
|
|
|
// Relay
|
|
|
|
//
|
|
|
|
if (event.type == "AddRelayButtonClicked") {
|
|
|
|
// todo: need to think about concurrent/async UI update
|
|
|
|
app.relayPool.addRelayURL(event.url).then((err) => {
|
|
|
|
if (err instanceof Error) {
|
|
|
|
app.model.AddRelayButtonClickedError = err.message;
|
|
|
|
} else {
|
|
|
|
app.model.AddRelayButtonClickedError = "";
|
|
|
|
}
|
|
|
|
});
|
|
|
|
app.model.AddRelayInput = "";
|
|
|
|
} else if (event.type == "AddRelayInputChange") {
|
|
|
|
app.model.AddRelayInput = event.url;
|
|
|
|
} else if (event.type == "RemoveRelayButtonClicked") {
|
|
|
|
await app.relayPool.removeRelay(event.url);
|
|
|
|
} //
|
|
|
|
//
|
|
|
|
// Search
|
|
|
|
//
|
|
|
|
else if (event.type == "CancelSearch") {
|
|
|
|
app.model.dm.search.isSearching = false;
|
|
|
|
app.model.dm.search.searchResults = [];
|
|
|
|
} else if (event.type == "StartSearch") {
|
|
|
|
app.model.dm.search.isSearching = true;
|
|
|
|
} else if (event.type == "Search") {
|
|
|
|
const pubkey = PublicKey.FromString(event.text);
|
|
|
|
if (pubkey instanceof PublicKey) {
|
|
|
|
await profileSyncer.add(pubkey.hex);
|
2023-07-04 06:37:14 +00:00
|
|
|
const profile = getProfileEvent(app.database, pubkey);
|
2023-06-30 14:05:57 +00:00
|
|
|
app.model.dm.search.searchResults = [{
|
|
|
|
pubkey: pubkey,
|
|
|
|
profile: profile?.content,
|
|
|
|
}];
|
|
|
|
} else {
|
|
|
|
const profiles = getProfilesByName(app.database, event.text);
|
|
|
|
app.model.dm.search.searchResults = profiles.map((p) => {
|
|
|
|
const pubkey = PublicKey.FromString(p.pubkey);
|
|
|
|
if (pubkey instanceof Error) {
|
|
|
|
throw new Error("impossible");
|
|
|
|
}
|
|
|
|
return {
|
|
|
|
pubkey: pubkey,
|
|
|
|
profile: p.content,
|
|
|
|
};
|
|
|
|
});
|
|
|
|
}
|
|
|
|
} //
|
|
|
|
//
|
|
|
|
// Contacts
|
|
|
|
//
|
|
|
|
else if (event.type == "SelectProfile") {
|
2023-07-09 07:06:13 +00:00
|
|
|
if (!app.myAccountContext) {
|
|
|
|
throw new Error(`can't handle SelectProfile if not signed`);
|
|
|
|
}
|
2023-06-30 14:05:57 +00:00
|
|
|
app.model.dm.search.isSearching = false;
|
|
|
|
app.model.dm.search.searchResults = [];
|
|
|
|
app.model.rightPanelModel = {
|
|
|
|
show: false,
|
|
|
|
};
|
|
|
|
const group = getGroupOf(
|
|
|
|
event.pubkey,
|
|
|
|
getAllUsersInformation(app.database, app.myAccountContext),
|
|
|
|
);
|
|
|
|
app.model.dm.selectedContactGroup = group;
|
|
|
|
updateConversation(app.model, event.pubkey);
|
|
|
|
|
|
|
|
if (!app.model.dm.focusedContent.get(event.pubkey.hex)) {
|
|
|
|
app.model.dm.focusedContent.set(event.pubkey.hex, event.pubkey);
|
|
|
|
}
|
|
|
|
} else if (event.type == "BackToContactList") {
|
|
|
|
app.model.dm.currentSelectedContact = undefined;
|
|
|
|
} else if (event.type == "SelectGroup") {
|
|
|
|
app.model.dm.selectedContactGroup = event.group;
|
|
|
|
} else if (event.type == "PinContact" || event.type == "UnpinContact") {
|
2023-07-09 07:06:13 +00:00
|
|
|
if (!app.myAccountContext) {
|
|
|
|
throw new Error(`can't handle ${event.type} if not signed`);
|
|
|
|
}
|
2023-06-30 14:05:57 +00:00
|
|
|
const nostrEvent = await prepareCustomAppDataEvent(app.myAccountContext, event);
|
|
|
|
if (nostrEvent instanceof Error) {
|
|
|
|
console.error(nostrEvent);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
const err = await app.relayPool.sendEvent(nostrEvent);
|
|
|
|
if (err instanceof Error) {
|
|
|
|
console.error(err);
|
|
|
|
}
|
|
|
|
console.log("send", nostrEvent);
|
|
|
|
} //
|
|
|
|
//
|
|
|
|
// Editor
|
|
|
|
//
|
|
|
|
else if (event.type == "SendMessage") {
|
2023-07-09 07:06:13 +00:00
|
|
|
if (!app.myAccountContext) {
|
|
|
|
throw new Error(`can't handle ${event.type} if not signed`);
|
|
|
|
}
|
2023-06-30 14:05:57 +00:00
|
|
|
if (event.target.kind == NostrKind.DIRECT_MESSAGE) {
|
2023-07-09 12:43:03 +00:00
|
|
|
const err = await sendDMandImages({
|
2023-06-30 14:05:57 +00:00
|
|
|
sender: app.myAccountContext,
|
2023-07-11 09:19:57 +00:00
|
|
|
receiverPublicKey: event.target.receiver.pubkey,
|
2023-06-30 14:05:57 +00:00
|
|
|
message: event.text,
|
|
|
|
files: event.files,
|
|
|
|
kind: event.target.kind,
|
|
|
|
lamport_timestamp: lamport.now(),
|
|
|
|
pool: app.relayPool,
|
|
|
|
waitAll: false,
|
|
|
|
tags: event.tags,
|
|
|
|
});
|
2023-07-09 12:43:03 +00:00
|
|
|
if (err instanceof Error) {
|
|
|
|
console.error("update:SendMessage", err);
|
|
|
|
continue; // todo: global error toast
|
|
|
|
}
|
2023-06-30 14:05:57 +00:00
|
|
|
const editor = app.model.editors.get(event.id);
|
|
|
|
if (editor) {
|
|
|
|
editor.files = [];
|
|
|
|
editor.text = "";
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
sendSocialPost({
|
|
|
|
sender: app.myAccountContext,
|
|
|
|
message: event.text,
|
|
|
|
lamport_timestamp: lamport.now(),
|
|
|
|
pool: app.relayPool,
|
|
|
|
tags: event.tags,
|
|
|
|
});
|
|
|
|
if (event.id == "social") {
|
|
|
|
app.model.social.editor.files = [];
|
|
|
|
app.model.social.editor.text = "";
|
|
|
|
}
|
|
|
|
const editor = app.model.social.replyEditors.get(event.id);
|
|
|
|
if (editor) {
|
|
|
|
editor.files = [];
|
|
|
|
editor.text = "";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (event.type == "UpdateMessageFiles") {
|
|
|
|
if (event.target.kind == NostrKind.DIRECT_MESSAGE) {
|
|
|
|
const editor = app.model.editors.get(event.id);
|
|
|
|
if (editor) {
|
|
|
|
editor.files = event.files;
|
|
|
|
} else {
|
|
|
|
console.log(event.target.receiver, event.id);
|
|
|
|
throw new Error("impossible state");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (event.id == "social") {
|
|
|
|
app.model.social.editor.files = event.files;
|
|
|
|
} else {
|
|
|
|
const editor = app.model.social.replyEditors.get(event.id);
|
|
|
|
if (editor) {
|
|
|
|
editor.files = event.files;
|
|
|
|
} else {
|
|
|
|
throw new Error("impossible state");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (event.type == "UpdateMessageText") {
|
|
|
|
if (event.target.kind == NostrKind.DIRECT_MESSAGE) {
|
|
|
|
const editor = app.model.editors.get(event.id);
|
|
|
|
if (editor) {
|
|
|
|
editor.text = event.text;
|
|
|
|
} else {
|
|
|
|
console.log(event.target.receiver, event.id);
|
|
|
|
throw new Error("impossible state");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (event.id == "social") {
|
|
|
|
app.model.social.editor.text = event.text;
|
|
|
|
} else {
|
|
|
|
const editor = app.model.social.replyEditors.get(event.id);
|
|
|
|
if (editor) {
|
|
|
|
editor.text = event.text;
|
|
|
|
} else {
|
|
|
|
throw new Error("impossible state");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} //
|
|
|
|
//
|
|
|
|
// MyProfile
|
|
|
|
//
|
|
|
|
else if (event.type == "EditMyProfile") {
|
|
|
|
app.model.myProfile = Object.assign(app.model.myProfile || {}, event.profile);
|
|
|
|
} else if (event.type == "SaveMyProfile") {
|
2023-07-09 07:06:13 +00:00
|
|
|
if (!app.myAccountContext) {
|
|
|
|
throw new Error(`can't handle ${event.type} if not signed`);
|
|
|
|
}
|
2023-06-30 14:05:57 +00:00
|
|
|
InsertNewProfileField(app.model);
|
|
|
|
await saveProfile(
|
|
|
|
event.profile,
|
|
|
|
app.myAccountContext,
|
|
|
|
app.relayPool,
|
|
|
|
);
|
|
|
|
} else if (event.type == "EditNewProfileFieldKey") {
|
|
|
|
app.model.newProfileField.key = event.key;
|
|
|
|
} else if (event.type == "EditNewProfileFieldValue") {
|
|
|
|
app.model.newProfileField.value = event.value;
|
|
|
|
} else if (event.type == "InsertNewProfileField") {
|
|
|
|
InsertNewProfileField(app.model);
|
|
|
|
} //
|
|
|
|
//
|
|
|
|
// Navigation
|
|
|
|
//
|
|
|
|
else if (event.type == "ChangeNavigation") {
|
|
|
|
app.model.navigationModel.activeNav = event.index;
|
|
|
|
app.model.rightPanelModel = {
|
|
|
|
show: false,
|
|
|
|
};
|
|
|
|
} //
|
|
|
|
//
|
|
|
|
// DM
|
|
|
|
//
|
|
|
|
else if (event.type == "ToggleRightPanel") {
|
|
|
|
app.model.rightPanelModel.show = event.show;
|
|
|
|
} else if (event.type == "ViewThread") {
|
|
|
|
if (app.model.navigationModel.activeNav == "Social") {
|
|
|
|
app.model.social.focusedContent = event.root;
|
|
|
|
} else if (app.model.navigationModel.activeNav == "DM") {
|
|
|
|
if (app.model.dm.currentSelectedContact) {
|
|
|
|
app.model.dm.focusedContent.set(
|
|
|
|
app.model.dm.currentSelectedContact.hex,
|
|
|
|
event.root,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
app.model.rightPanelModel.show = true;
|
|
|
|
} else if (event.type == "ViewUserDetail") {
|
|
|
|
if (app.model.navigationModel.activeNav == "Social") {
|
|
|
|
app.model.social.focusedContent = event.pubkey;
|
|
|
|
} else if (
|
|
|
|
app.model.navigationModel.activeNav == "DM"
|
|
|
|
) {
|
|
|
|
if (app.model.dm.currentSelectedContact) {
|
|
|
|
app.model.dm.focusedContent.set(
|
|
|
|
app.model.dm.currentSelectedContact.hex,
|
|
|
|
event.pubkey,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
app.model.rightPanelModel.show = true;
|
|
|
|
}
|
|
|
|
yield app.model;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
export function getConversationMessages(args: {
|
|
|
|
database: Database;
|
|
|
|
pub1: string;
|
|
|
|
pub2: string;
|
|
|
|
allUserInfo: Map<string, UserInfo>;
|
|
|
|
}): MessageThread[] {
|
|
|
|
const { database, pub1, pub2, allUserInfo } = args;
|
|
|
|
let t = Date.now();
|
|
|
|
const events = get_Kind4_Events_Between(database, pub1, pub2);
|
|
|
|
// console.log("getConversationMessages:filter events", Date.now() - t)
|
|
|
|
const threads = computeThreads(Array.from(events));
|
|
|
|
// console.log("getConversationMessages:compute threads", Date.now() - t)
|
|
|
|
const msgs: MessageThread[] = [];
|
|
|
|
for (const thread of threads) {
|
|
|
|
const messages = convertEventsToChatMessages(thread, allUserInfo);
|
|
|
|
if (messages.length > 0) {
|
|
|
|
messages.sort((m1, m2) => {
|
|
|
|
if (m1.lamport && m2.lamport && m1.lamport != m2.lamport) {
|
|
|
|
return m1.lamport - m2.lamport;
|
|
|
|
}
|
|
|
|
return m1.created_at.getTime() - m2.created_at.getTime();
|
|
|
|
});
|
|
|
|
msgs.push({
|
|
|
|
root: messages[0],
|
|
|
|
replies: messages.slice(1),
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
console.log("getConversationMessages:convert", Date.now() - t);
|
|
|
|
return msgs;
|
|
|
|
}
|
|
|
|
|
|
|
|
export function updateConversation(
|
|
|
|
model: Model,
|
|
|
|
targetPublicKey: PublicKey,
|
|
|
|
) {
|
|
|
|
model.dm.hasNewMessages.delete(targetPublicKey.hex);
|
|
|
|
// If this conversation is new
|
|
|
|
if (!model.editors.has(targetPublicKey.hex)) {
|
|
|
|
model.editors.set(targetPublicKey.hex, {
|
|
|
|
id: targetPublicKey.hex,
|
|
|
|
files: [],
|
|
|
|
text: "",
|
|
|
|
tags: [],
|
|
|
|
target: {
|
|
|
|
kind: NostrKind.DIRECT_MESSAGE,
|
|
|
|
receiver: {
|
|
|
|
pubkey: targetPublicKey,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
});
|
|
|
|
}
|
|
|
|
model.dm.currentSelectedContact = targetPublicKey;
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////
|
|
|
|
// Database //
|
|
|
|
//////////////
|
|
|
|
export async function* Database_Update(
|
|
|
|
ctx: NostrAccountContext,
|
|
|
|
database: Database,
|
|
|
|
model: Model,
|
|
|
|
profileSyncer: ProfilesSyncer,
|
|
|
|
lamport: LamportTime,
|
|
|
|
eventEmitter: EventEmitter<SelectProfile>,
|
|
|
|
) {
|
|
|
|
const changes = database.onChange((_) => true);
|
|
|
|
while (true) {
|
|
|
|
await csp.sleep(333);
|
|
|
|
await changes.ready();
|
|
|
|
const changes_events: NostrEvent[] = [];
|
|
|
|
while (true) {
|
|
|
|
if (!changes.isReadyToPop()) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
const e = await changes.pop();
|
|
|
|
if (e == csp.closed) {
|
|
|
|
console.error("unreachable: db changes channel should never close");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
changes_events.push(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (let e of changes_events) {
|
|
|
|
const t = getTags(e).lamport_timestamp;
|
|
|
|
if (t) {
|
|
|
|
lamport.set(t);
|
|
|
|
}
|
|
|
|
const key = PublicKey.FromHex(e.pubkey);
|
|
|
|
if (key instanceof PublicKey) {
|
|
|
|
await profileSyncer.add(key.hex);
|
|
|
|
}
|
|
|
|
if (e.kind == NostrKind.META_DATA || e.kind == NostrKind.DIRECT_MESSAGE) {
|
|
|
|
const contacts = getAllUsersInformation(database, ctx);
|
|
|
|
for (const contact of contacts.values()) {
|
|
|
|
const editor = model.editors.get(contact.pubkey.hex);
|
|
|
|
if (editor == null) { // a stranger sends a message
|
|
|
|
const pubkey = PublicKey.FromHex(contact.pubkey.hex);
|
|
|
|
if (pubkey instanceof Error) {
|
|
|
|
throw pubkey; // impossible
|
|
|
|
}
|
|
|
|
model.editors.set(
|
|
|
|
contact.pubkey.hex,
|
|
|
|
new_DM_EditorModel({
|
|
|
|
pubkey,
|
|
|
|
}),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (model.dm.currentSelectedContact) {
|
|
|
|
updateConversation(
|
|
|
|
model,
|
|
|
|
model.dm.currentSelectedContact,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (e.kind == NostrKind.META_DATA) {
|
|
|
|
if (model.dm.search.searchResults.length > 0) {
|
|
|
|
const previous = model.dm.search.searchResults;
|
|
|
|
model.dm.search.searchResults = previous.map((profile) => {
|
2023-07-04 06:37:14 +00:00
|
|
|
const profileEvent = getProfileEvent(database, profile.pubkey);
|
2023-06-30 14:05:57 +00:00
|
|
|
return {
|
|
|
|
pubkey: profile.pubkey,
|
|
|
|
profile: profileEvent?.content,
|
|
|
|
};
|
|
|
|
});
|
|
|
|
}
|
|
|
|
// my profile update
|
|
|
|
if (ctx && e.pubkey == ctx.publicKey.hex) {
|
2023-07-04 06:37:14 +00:00
|
|
|
const newProfile = getProfileEvent(database, ctx.publicKey);
|
2023-06-30 14:05:57 +00:00
|
|
|
if (newProfile == undefined) {
|
|
|
|
throw new Error("impossible");
|
|
|
|
}
|
|
|
|
model.myProfile = newProfile.content;
|
|
|
|
}
|
|
|
|
} else if (e.kind == NostrKind.DIRECT_MESSAGE) {
|
2023-07-04 06:37:14 +00:00
|
|
|
const pubkey = PublicKey.FromHex(e.pubkey);
|
|
|
|
if (pubkey instanceof Error) {
|
|
|
|
console.error(pubkey);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
const author = getProfileEvent(database, pubkey);
|
2023-06-30 14:05:57 +00:00
|
|
|
if (e.pubkey != ctx.publicKey.hex) {
|
|
|
|
notify(
|
|
|
|
author?.content.name ? author.content.name : "",
|
|
|
|
"new message",
|
|
|
|
author?.content.picture ? author.content.picture : "",
|
|
|
|
() => {
|
|
|
|
const k = PublicKey.FromHex(e.pubkey);
|
|
|
|
if (k instanceof Error) {
|
|
|
|
console.error(k);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
eventEmitter.emit({
|
|
|
|
type: "SelectProfile",
|
|
|
|
pubkey: k,
|
|
|
|
});
|
|
|
|
},
|
|
|
|
);
|
|
|
|
model.dm.currentSelectedContact;
|
|
|
|
if (model.dm.currentSelectedContact?.hex != e.pubkey) {
|
|
|
|
model.dm.hasNewMessages.add(e.pubkey);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (e.kind == NostrKind.CustomAppData) {
|
|
|
|
const contacts = getAllUsersInformation(database, ctx);
|
|
|
|
for (const contact of contacts.values()) {
|
|
|
|
const editor = model.editors.get(contact.pubkey.hex);
|
|
|
|
if (editor == null) {
|
|
|
|
throw new Error("impossible");
|
|
|
|
} else {
|
|
|
|
// chatModel.userInfo = contact;
|
|
|
|
// quetion: do nothing?
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (e.kind == NostrKind.TEXT_NOTE) {
|
|
|
|
// do nothing
|
|
|
|
} else {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
yield model;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
///////////
|
|
|
|
// Relay //
|
|
|
|
///////////
|
|
|
|
export async function* Relay_Update(relayPool: ConnectionPool) {
|
|
|
|
for await (const _ of relayPool.onChange()) {
|
|
|
|
for (const relay of relayPool.getRelays()) {
|
|
|
|
if (relay.isClosed() && !relay.isClosedByClient) {
|
|
|
|
await relayPool.removeRelay(relay.url);
|
|
|
|
while (true) {
|
|
|
|
const err = await relayPool.addRelayURL(relay.url);
|
|
|
|
if (err) {
|
|
|
|
console.error(err);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
yield;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function InsertNewProfileField(model: Model) {
|
|
|
|
if (model.newProfileField.key && model.newProfileField.value) {
|
|
|
|
model.myProfile = Object.assign(model.myProfile || {}, {
|
|
|
|
[model.newProfileField.key]: model.newProfileField.value,
|
|
|
|
});
|
|
|
|
model.newProfileField = {
|
|
|
|
key: "",
|
|
|
|
value: "",
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|