Delete readmes, update docs

packages/app/src/adapters.ts

@@ -0,0 +1,103 @@
+import {get, derived} from 'svelte/store'
+import {batch, fromPairs} from '@welshman/lib'
+import {PROFILE, FOLLOWS, MUTES, RELAYS, INBOX_RELAYS, getPubkeyTagValues, getListTags} from '@welshman/util'
+import {throttled, withGetter} from '@welshman/store'
+import {RepositoryUpdate} from '@welshman/relay'
+import {getAll, bulkPut, bulkDelete} from './storage.js'
+import {relays} from './relays.js'
+import {handles, onHandle} from './handles.js'
+import {zappers, onZapper} from './zappers.js'
+import {plaintext} from './plaintext.js'
+import {freshness} from './freshness.js'
+import {repository} from './core.js'
+import {sessions} from './session.js'
+import {userFollows} from './user.js'
+
+export const defaultStorageAdapters = {
+  relays: {
+    keyPath: "url",
+    init: async () => relays.set(await getAll("relays")),
+    sync: () => throttled(3000, relays).subscribe($relays => bulkPut("relays", $relays)),
+  },
+  handles: {
+    keyPath: "nip05",
+    init: async () => handles.set(await getAll("handles")),
+    sync: () => onHandle(batch(300, $handles => bulkPut("handles", $handles))),
+  },
+  zappers: {
+    keyPath: "lnurl",
+    init: async () => zappers.set(await getAll("zappers")),
+    sync: () => onZapper(batch(300, $zappers => bulkPut("zappers", $zappers))),
+  },
+  freshness: {
+    keyPath: "key",
+    init: async () => {
+      const items = await getAll("freshness")
+
+      freshness.set(fromPairs(items.map(item => [item.key, item.value])))
+    },
+    sync: () => {
+      const interval = setInterval(() => {
+        bulkPut(
+          "freshness",
+          Object.entries(freshness.get()).map(([key, value]) => ({key, value})),
+        )
+      }, 10_000)
+
+      return () => clearInterval(interval)
+    },
+  },
+  plaintext: {
+    keyPath: "key",
+    init: async () => {
+      const items = await getAll("plaintext")
+
+      plaintext.set(fromPairs(items.map(item => [item.key, item.value])))
+    },
+    sync: () => {
+      const interval = setInterval(() => {
+        bulkPut(
+          "plaintext",
+          Object.entries(plaintext.get()).map(([key, value]) => ({key, value})),
+        )
+      }, 10_000)
+
+      return () => clearInterval(interval)
+    },
+  },
+  events: {
+    keyPath: "id",
+    init: async () => repository.load(await getAll("events")),
+    sync: () => {
+      const userFollowPubkeys = withGetter(
+        derived(userFollows, l => new Set(getPubkeyTagValues(getListTags(l))))
+      )
+
+      const onUpdate = async ({added, removed}: RepositoryUpdate) => {
+        const sessionKeys = new Set(Object.keys(sessions.get()))
+        const metaKinds = [PROFILE, FOLLOWS, MUTES, RELAYS, INBOX_RELAYS]
+
+        if (removed.size > 0) {
+          await bulkDelete("events", Array.from(removed))
+        }
+
+        if (added.length > 0) {
+          await bulkPut(
+            "events",
+            added.filter(e => {
+              if (sessionKeys.has(e.pubkey)) return true
+              if (e.tags.some(t => sessionKeys.has(t[1]))) return true
+              if (metaKinds.includes(e.kind) && userFollowPubkeys.get()?.has(e.pubkey)) return true
+
+              return false
+            }),
+          )
+        }
+      }
+
+      repository.on("update", onUpdate)
+
+      return () => repository.off("update", onUpdate)
+    },
+  },
+}

packages/app/src/collection.ts

@@ -1,5 +1,5 @@
 import {readable, derived, type Readable, type Subscriber} from "svelte/store"
-import {indexBy, remove, type Maybe, now} from "@welshman/lib"
+import {indexBy, remove, now} from "@welshman/lib"
 import {withGetter} from "@welshman/store"
 import {getFreshness, setFreshnessThrottled} from "./freshness.js"
 
@@ -15,7 +15,7 @@ export const collection = <T>({
   load?: (key: string, relays: string[]) => Promise<any>
 }) => {
   const indexStore = withGetter(derived(store, $items => indexBy(getKey, $items)))
-  const pending = new Map<string, Promise<Maybe<T>>>()
+  const pending = new Map<string, Promise<T | void>>()
   const loadAttempts = new Map<string, number>()
 
   let subscribers: Subscriber<T>[] = []
@@ -76,7 +76,7 @@ export const collection = <T>({
     return fresh
   }
 
-  const deriveItem = (key: Maybe<string>, relays: string[] = []) => {
+  const deriveItem = (key: string | undefined, relays: string[] = []) => {
     if (!key) {
       return readable(undefined)
     }

packages/app/src/index.ts

@@ -1,3 +1,4 @@
+export * from "./adapters.js"
 export * from "./context.js"
 export * from "./core.js"
 export * from "./collection.js"