I did some caching work, I think? Also: increment demo for pro site.

readme

···
 bro idk what this is anymore but im a fan of it and will keep going
 
 i really gotta stop using Node.wraps...
-that literally means that my implementation around it is inadequate
+that literally means that my implementation around it is inadequate
+
+i hate git sometimes

src/desktop.ts

···
 import { Body, Button, Column, Input, Link, Row } from "./domlink.ts";
 import { List, SocialAppToURI } from "./support/bluesky.ts";
+import { DocProxy } from "./support/caching.ts";
 import { getUriRecord, resolveMiniDoc } from "./support/slingshot.ts";
 import { Window } from "./windowing_mod.ts";
 import { Feed } from "./windows/bluesky/feed.ts";
···
 ).closable(false); // haha
 
 export const displayAuthorFeed = async (user: string) => {
-	const doc = await resolveMiniDoc(user);
+	const doc = await DocProxy.get(user);
 	Body.with(new Window("Posts by @"+doc.handle).with(
 		await new Feed().loadFeed(Feed.createAuthorGenerator(doc.did)),
 	));
···
 	listInput,
 	new Button("Get List Feed", async () => {
 		const listURI = await SocialAppToURI(listInput.value, true);
-		const doc = await resolveMiniDoc(listURI.authority!);
+		const doc = await DocProxy.get(listURI.authority!);
 		const listInfo = await getUriRecord<List>(listURI);
 		try{
 			Body.with(new Window(`Posts in "${listInfo.value.name}" by @${doc.handle}`).with(
···
 const tangledIssuesWindowCreator = new Row().with(
 	repoInput,
 	new Button("Get Issues", async () => {
-		const search = new IssueSearch();
+		const issueWindow = new Window();
+		const search = new IssueSearch(issueWindow);
+		issueWindow.with(search);
 		try {
 			await search.getIssues(repoInput.value);
 		} catch (e) {
 			alert(e);
 		}
-		Body.with(new Window(`Issues in @${search.repoInfo.owner}/${search.repoInfo.name}`).with(
-			search
-		));
+		Body.with(issueWindow);
 	})
 );
 

src/increment.ts

···
+import { Body, Button, Column, Label } from "@/domlink.ts";
+
+const display = new Label("Number: 0");
+let number = 0;
+Body.with(
+	new Column().with(
+		new Button("Increment!", ()=>{
+			display.text = `Number: ${++number}`;
+		})
+	)
+);

src/support/atproto.ts

···
 	return NSIDExpression.test(nsid) ? nsid : null;
 }
 
+export type Handle = string;
+export function StripHandle(handle: Handle) {
+	return handle.replace("@", "");
+}
 export type DID = `did:${"web"|"plc"}:${string}`;
 export function ValidateDID(did: string): string | null  {
 	const parts = did.split(":");
···
 
 // technically you can cast it to whatever you want but i feel like using a generic(?) makes it cleaner
 /** Calls an XRPC "query" method (HTTP GET) 
- * @param service Defaults to {@link https://slingshot.microcosm.blue Slingshot}. 
+ * @param service Defaults to the {@link https://api.bsky.app/ Bluesky (PBC) API} service.
 */
 export async function XQuery<T>(method: string, params: Record<string, string | number | null> | null = null, service: string = DEFAULT_SERVICE) {
 	let QueryURL = `${service}/xrpc/${method}`;

src/support/bluesky.ts

···
 import { AppBskyFeedDefs } from "@atcute/bluesky";
 import { AtURI, DID } from "./atproto.ts";
 import * as Constellation from "./constellation.ts";
-import { getUriRecord, resolveHandle } from "./slingshot.ts";
+import { getUriRecord } from "./slingshot.ts";
+import { DocProxy } from "./caching.ts";
 
 export type FeedResponse = {
 	feed: AppBskyFeedDefs.FeedViewPost[];
···
 	const url = new URL(link);
 	const parts = url.pathname.split("/").splice(1);
 	console.log(parts);
-	let handle = parts[1];
+	let id = parts[1];
 	if (resolve) {
-		handle = (await resolveHandle(handle)).toString();
+		id = (await DocProxy.get(id)).handle;
 	}
 	if (parts[0] == "profile" && parts.length >= 2) {
-		if (parts.length == 2) return new AtURI(handle);
-		if (parts.length == 4) return new AtURI(handle, partMap.get(parts[2])!, parts[3]);
+		if (parts.length == 2) return new AtURI(id);
+		if (parts.length == 4) return new AtURI(id, partMap.get(parts[2])!, parts[3]);
 	}
-	if (parts[0] == "starter-pack" && parts.length == 3) return new AtURI(handle, "app.bsky.graph.starterpack", parts[2]);
+	if (parts[0] == "starter-pack" && parts.length == 3) return new AtURI(id, "app.bsky.graph.starterpack", parts[2]);
 	throw new Error("URL provided is not under /profile nor /starter-pack");
 }
 
···
 	createdAt: Date;
 };
 export async function GetListItems(list: AtURI) {
-	return (await Promise.all((await Constellation.getLinks(list, "app.bsky.graph.listitem", ".list"))
+	return (await Promise.all((await Constellation.getLinks(list.toString()!, "app.bsky.graph.listitem", ".list"))
 		.map(async x=>await getUriRecord<ListItem>(x))));
 }

src/support/caching.ts

···
+import { DID, Handle, StripHandle } from "./atproto.ts";
+import { MiniDoc, resolveMiniDoc } from "./slingshot.ts";
+
+type Identifier = DID | Handle;
+type PromiseCallbacks = {
+	resolve: (doc: MiniDoc) => void;
+	reject: (err: unknown) => void;
+}
+
+class _DocCache {
+	cache: Map<Identifier, MiniDoc> = new Map();
+	waiting: Map<Identifier, PromiseCallbacks[]> = new Map();
+	async get(k: Identifier): Promise<MiniDoc> {
+		const key = StripHandle(k);
+		if (this.cache.has(key)) {
+			console.debug("cache hit " + key);
+			return this.cache.get(key)!;
+		}
+
+		if (this.waiting.has(key)) {
+			console.debug("cache soft miss " + key);
+			return new Promise((resolve, reject)=>{
+				this.waiting.get(key)!.push({resolve, reject});
+			});
+		}
+
+		this.waiting.set(key, []);
+		try {
+			console.debug("cache hard miss " + key);
+			const grabbed = await resolveMiniDoc(key);
+			this.cache.set(key, grabbed);
+			this.cache.set(grabbed.did, grabbed);
+			this.cache.set(grabbed.handle, grabbed);
+			this.waiting.get(key)!.forEach(p => p.resolve(grabbed));
+			return grabbed;
+		} catch (error) {
+			this.waiting.get(key)!.forEach(p => p.reject(error));
+			throw error;
+		} finally {
+			this.waiting.delete(key);
+		}
+	}
+}
+
+export const DocProxy = new _DocCache();

src/support/tangled.ts

···
-import * as x from "../extras.ts";
-import { AtURI, ListRecords, XQuery } from "./atproto.ts";
+import * as x from "@/extras.ts";
+import { AtURI, DID, GetRecord, ListRecords } from "./atproto.ts";
 import { getUriRecord, MiniDoc } from "./slingshot.ts";
 import * as Constellation from "./constellation.ts";
+import { DocProxy } from "./caching.ts";
 
 export type Issue = {
 	body: string;
 	createdAt: string;
 	issueId: number;
-	owner: string;
+	owner: DID;
+	ownerHandle: string;
 	repo: string;
-	title: string; 
+	title: string;
+	uri: AtURI; // not part of actual issue
+};
+export enum IssueStateValues {
+	Open = "sh.tangled.repo.issue.state.open",
+	Closed = "sh.tangled.repo.issue.state.closed"
+}
+export type IssueState = {
+	issue: AtURI;
+	state: IssueStateValues;
+};
+
+export type IssueMeta = {
+	issue: Issue;
+	state: IssueState;
 };
 export type RepoRef = {
 	readonly owner: string;
···
 };
 
 export async function GetRepo(ref: RepoRef): Promise<Repo> {
-	const repoOwnerDoc = await XQuery<MiniDoc>("com.bad-example.identity.resolveMiniDoc", {identifier: ref.owner});
+	const repoOwnerDoc = await DocProxy.get(ref.owner);
 	const ownedRepos = await ListRecords<RawRepo>(repoOwnerDoc.did, "sh.tangled.repo", repoOwnerDoc.pds);
 	const repoRecord = ownedRepos.records.find(x=>x.value.name == ref.name)!;
 	return {
···
 	};
 }
 export async function GetIssues(repo: Repo, timeout: number = 10000) {
-	const allIssueRefs = await x.timeout(timeout, Constellation.links(repo.uri, "sh.tangled.repo.issue", ".repo"));
-	const issues = allIssueRefs.map(async (uri)=>{
+	const allIssueRefs = await x.timeout(timeout, Constellation.getLinks(repo.uri.toString()!, "sh.tangled.repo.issue", ".repo"));
+	const issues = await Promise.all(allIssueRefs.map(async (uri)=>{
 		try {
-			return (await x.timeout(timeout/5,getUriRecord<Issue>(uri))).value;
+			const issue = (await x.timeout(timeout/5,getUriRecord<Issue>(uri))).value;
+			issue.uri = uri;
+			issue.ownerHandle = (await DocProxy.get(issue.owner)).handle;
+			return issue;
 		} catch {
 			console.log(`issue timed out: ${uri.toString()}`);
 			return null;
 		}
-	}).filter(x=>x!=null) as unknown as Issue[]; // despite filtering them out, typescript still thinks there could be nulls
-	return issues.sort((a,b)=>b.issueId-a.issueId);
+	})) as unknown as Issue[]; // despite filtering them out, typescript still thinks there could be nulls
+	return issues.filter(x=>x!=null).sort((a,b)=>b.issueId-a.issueId);
+}
+export async function GetIssueState(issue: Issue) {
+	const ref = await Constellation.getLinks(issue.uri.toString()!, "sh.tangled.repo.issue.state", ".issue");
+	const state = GetRecord<IssueState>(ref[0]);
+	return state;
+}
+export async function GetIssueWithMeta(uri: AtURI) {
+	const issue = (await getUriRecord<Issue>(uri)).value;
+	const state = await GetIssueState(issue);
+	return {issue, state};
 }
 
 /** Takes a string like `tangled.sh/core` or `https://tangled.sh/@tangled.sh/core` and returns a {@link RepoRef} */

src/windowing_mod.ts

···
 	}
 
 	front() {
-		this.wraps.style.zIndex = `${Window.zIndexCounter++}`;
+		this.style((s)=>{
+			s.zIndex = `${Window.zIndexCounter++}`;
+		});
 	}
 
 	override with(...nodes: (Node | string)[]): this {

src/windows/bluesky/feed.ts

···
 // formerly src/main.ts. how far we've come. 
 
-import { Button, Column, Container, Image, Label, Row } from "@/domlink.ts";
+import { Button, Column, Container, Image, Row } from "@/domlink.ts";
 import { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/bluesky';
 import { AtURI, XQuery } from "@/support/atproto.ts";
 import { FeedResponse as RawFeedResponse } from "@/support/bluesky.ts";

src/windows/tangled/issuesearch.ts

···
 // rewrite of @/issuesearch.ts to be a self-contained class that can be shoved into a window easily
 
 import { Column, Container, Node, Input, Link, Row, Table, TableCell, TableRow, Button } from "@/domlink.ts";
-import { ListRecords } from "@/support/atproto.ts";
-import { getUriRecord, resolveMiniDoc } from "@/support/slingshot.ts";
-import { Issue, Repo, RepoRecord } from "@/support/tangled.ts";
-import * as Constellation from "@/support/constellation.ts";
-import { timeout } from "@/extras.ts";
+import { GetIssues, GetRepo, Issue, RepoRef } from "@/support/tangled.ts";
+import { Window } from "@/windowing_mod.ts";
 
 export class IssueSearch extends Column {
 	repoInput = new Input();
 	searchInput = new Input();
 	searchRow = new Row().with("Search: ", this.searchInput).style(s=>s.display="none");
 	renderOut: Node = new Container().with("<nothing yet>");
-	repoInfo: RepoRecord = {} as RepoRecord;
+	repoInfo: RepoRef = {} as RepoRef;
 	issues: Issue[] = [];
-	constructor() {
+	window: Window | null = null;
+	constructor(window: Window | null = null) {
 		super();
+		if (window) {
+			this.window = window;
+		}
 		this.class("IssueSearch");
 		this.with(
-			new Row().with("Repo: ", this.repoInput, new Button("Get", async ()=>{await this.getIssues(this.repoInput.value);})),
-			this.searchRow,
+			new Row().with("Repo: ", this.repoInput, new Button("Get", async ()=>{await this.getIssues(this.repoInput.value);}), this.searchRow),
 			this.renderOut
 		);
 		this.searchInput.watch((search)=>{
···
 	}
 	async getIssues(repo: string) {
 		this.repoInfo = IssueSearch.parseRepoInfo(repo);
-		const doc = await resolveMiniDoc(this.repoInfo.owner);
-		const ownedRepos = await ListRecords<Repo>(doc.did, "sh.tangled.repo", doc.pds);
-		const repoRecord = ownedRepos.records.find(x=>x.value.name == this.repoInfo.name)!;
-		const links = await Constellation.getLinks(repoRecord.uri, "sh.tangled.repo.issue", ".repo");
-		this.issues = (await Promise.all(links.map(link => {
-			try {
-				return timeout(2000, getUriRecord<Issue>(link));
-			} catch {
-				return null;
-			}
-		}))).filter(x=>x).map(x=>x!.value).sort((a,b)=>a.issueId-b.issueId);
+		this.repoInput.value = `@${this.repoInfo.owner}/${this.repoInfo.name}`;
+		if (window) this.window!.title = `Issues in @${this.repoInfo.owner}/${this.repoInfo.name}`;
+		const repoRecord = await GetRepo(this.repoInfo);
+		this.issues = await GetIssues(repoRecord);
 		this.searchRow.style(s=>s.removeProperty("display"));
 		this.render(this.issues);
 	}
···
 			new TableRow().with(
 				new TableCell().with("Handle"),
 				new TableCell().with("Issue#"),
-				new TableCell().with("Title")),
-			...issues.map(issue => new TableRow().with(
-				new TableCell().with(new Link(issue.owner).to(`https://tangled.sh/@${issue.owner}`)),
-				new TableCell().with(new Link(issue.issueId.toString()).to(`https://tangled.sh/@${this.repoInfo.owner}/${this.repoInfo.name}/issues/${issue.issueId}`)),
+				new TableCell().with("Title")).style(s=>s.fontWeight="bold"),
+			...(issues.map(issue => new TableRow().with(
+				new TableCell().with(new Link(`@${issue.ownerHandle}`).to(`https://tangled.sh/${issue.ownerHandle}`)),
+				new TableCell().with(new Link(`${issue.issueId}`).to(`https://tangled.sh/@${this.repoInfo.owner}/${this.repoInfo.name}/issues/${issue.issueId}`)),
 				new TableCell().with(issue.title)
-			))
+			)))
 		);
 		this.with(this.renderOut);
 	}

static/increment.html

···
+<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>DomLink Increment Demo</title>
+</head>
+<body>
+	<script src="increment.js" type="module"></script>
+</body>
+</html>