@atproto-ui/core 0.13.0

package/dist/records.js

@@ -0,0 +1,321 @@
+import { createAtprotoClient } from "./client.js";
+import { callAppviewRpc, callGetRecord, callListRecords } from "./rpc.js";
+import { extractCidFromCdnUrl } from "./utils/blob.js";
+var BLUESKY_COLLECTION_TO_ENDPOINT = {
+	"app.bsky.actor.profile": "app.bsky.actor.getProfile",
+	"app.bsky.feed.post": "app.bsky.feed.getPostThread"
+};
+function ensureCachedRecord(e, x) {
+	return x.bypassCache ? {
+		promise: x.loader(),
+		release: () => {}
+	} : e.ensure(x.did, x.collection, x.rkey, () => ({
+		promise: x.loader(),
+		abort: () => {}
+	}));
+}
+function fetchRepositoryRecord(e) {
+	let x = async () => {
+		try {
+			let x = await callGetRecord(e.service, e.did, e.collection, e.rkey);
+			if (!x.ok) throw Error("Failed to load record");
+			return x.data.value;
+		} catch (x) {
+			throw e.service.includes(".bsky.network") ? Error(`Record unavailable. The Bluesky PDS (${e.service}) may be unreachable or the account may be banned.`) : x;
+		}
+	};
+	return e.recordCache ? ensureCachedRecord(e.recordCache, {
+		did: e.did,
+		collection: e.collection,
+		rkey: e.rkey,
+		bypassCache: e.bypassCache,
+		loader: x
+	}) : {
+		promise: x(),
+		release: () => {}
+	};
+}
+function getBlueskyRecord(e) {
+	let x;
+	return {
+		promise: (async () => {
+			let S = e.handleOrDid.trim(), C = S.startsWith("did:") ? S : await e.resolver.resolveHandle(S), w = e.recordCache.ensure(C, e.collection, e.rkey, () => ({
+				promise: fetchBlueskyRecordUncached({
+					did: C,
+					collection: e.collection,
+					rkey: e.rkey,
+					appviewService: e.appviewService,
+					resolver: e.resolver,
+					skipAppview: e.skipAppview
+				}),
+				abort: () => {}
+			}));
+			return x = w.release, w.promise;
+		})(),
+		release: () => x?.()
+	};
+}
+function fetchBlueskyRecord(e) {
+	return e.recordCache.ensure(e.did, e.collection, e.rkey, () => ({
+		promise: fetchBlueskyRecordUncached(e),
+		abort: () => {}
+	}));
+}
+async function fetchBlueskyRecordUncached(e) {
+	let x;
+	if (!e.skipAppview && BLUESKY_COLLECTION_TO_ENDPOINT[e.collection]) try {
+		let x = await fetchFromAppview(e.did, e.collection, e.rkey, e.appviewService);
+		if (x) return {
+			record: x,
+			source: "appview"
+		};
+	} catch (e) {
+		x = e;
+	}
+	try {
+		let x = await callGetRecord(e.resolver.getSlingshotUrl(), e.did, e.collection, e.rkey);
+		if (x.ok) return {
+			record: x.data.value,
+			source: "slingshot"
+		};
+		throw Error("slingshot getRecord failed");
+	} catch (e) {
+		x = e;
+	}
+	let C = e.pdsEndpoint;
+	if (!C) try {
+		C = await e.resolver.pdsEndpointForDid(e.did);
+	} catch (e) {
+		x = e;
+	}
+	if (C) {
+		try {
+			let x = await callGetRecord(C, e.did, e.collection, e.rkey);
+			if (x.ok) return {
+				record: x.data.value,
+				source: "pds"
+			};
+			throw Error("pds getRecord failed");
+		} catch (e) {
+			x = e;
+		}
+		if (C.includes(".bsky.network")) throw Error(`Record unavailable. The Bluesky PDS (${C}) may be unreachable or the account may be banned.`);
+	}
+	throw x ?? /* @__PURE__ */ Error("Failed to fetch record from all sources");
+}
+async function fetchLatestRecord(e) {
+	let x = await callListRecords(e.service, e.did, e.collection, e.limit ?? 3);
+	if (!x.ok) throw Error("Failed to list records from PDS");
+	let S = x.data.records.find((e) => isValidTimestamp(e.value));
+	return S ? {
+		record: S.value,
+		rkey: S.rkey ?? extractRkey(S.uri),
+		empty: !1
+	} : { empty: !0 };
+}
+async function fetchPaginatedRecordsPage(e) {
+	let x = paginatedPageCacheKey(e);
+	return e.pageCache ? e.pageCache.ensure(x, () => fetchPaginatedRecordsPageUncached(e)).promise : fetchPaginatedRecordsPageUncached(e);
+}
+function primeBlueskyFeedCache(e) {
+	let x = /* @__PURE__ */ new Set(), S = /* @__PURE__ */ new Set(), C = /* @__PURE__ */ new Set();
+	for (let w of e.feed) {
+		let T = w.post;
+		if (T?.uri && T.record !== void 0) {
+			let x = parseAtUriLoose(T.uri);
+			if (x) {
+				let S = {
+					record: T.record,
+					source: "appview"
+				};
+				e.recordCache?.set(x.did, x.collection, x.rkey, S), C.add(`${x.did}::${x.collection}::${x.rkey}`);
+			}
+		}
+		for (let C of [
+			T?.author,
+			w.reason?.by,
+			T?.reply?.parent?.author
+		]) C?.did && (e.didCache?.memoize({
+			did: C.did,
+			handle: C.handle
+		}), x.add(C.did), hasAppviewProfileData(C) && (primeBlueskyProfileCache({
+			profile: C,
+			didCache: e.didCache,
+			recordCache: e.recordCache
+		}), S.add(C.did)));
+	}
+	return {
+		dids: x.size,
+		profiles: S.size,
+		records: C.size
+	};
+}
+function primeBlueskyProfileCache(e) {
+	return e.profile.did ? (e.didCache?.memoize({
+		did: e.profile.did,
+		handle: e.profile.handle
+	}), e.recordCache?.set(e.profile.did, "app.bsky.actor.profile", "self", {
+		record: appviewProfileToRecord(e.profile),
+		source: "appview"
+	}), {
+		dids: 1,
+		profiles: 1,
+		records: 0
+	}) : {
+		dids: 0,
+		profiles: 0,
+		records: 0
+	};
+}
+function hasAppviewProfileData(e) {
+	return "displayName" in e || "description" in e || "avatar" in e || "createdAt" in e || "pronouns" in e || "website" in e;
+}
+async function fetchPaginatedRecordsPageUncached(e) {
+	if (e.preferAuthorFeed && e.collection === "app.bsky.feed.post" && e.authorFeedActor) try {
+		let S = await callAppviewRpc(e.authorFeedService, "app.bsky.feed.getAuthorFeed", {
+			actor: e.authorFeedActor,
+			limit: e.limit,
+			cursor: e.cursor,
+			filter: e.authorFeedFilter,
+			includePins: e.authorFeedIncludePins
+		});
+		if (!S.ok) throw Error("Failed to fetch author feed");
+		return {
+			records: (S.data.feed ?? []).reduce((x, S) => {
+				let C = S.post;
+				return !C?.record || typeof C.uri != "string" || !isValidTimestamp(C.record) ? x : (x.push({
+					uri: C.uri,
+					rkey: extractRkey(C.uri),
+					value: C.record,
+					author: C.author,
+					reason: S.reason,
+					replyParent: C.reply?.parent
+				}), primePaginatedRecordCache(e, C.uri, C.record), primeDidCache(e, C.author), primeDidCache(e, S.reason?.by), primeDidCache(e, C.reply?.parent?.author), primeAuthorProfileCache(e, C.author), x);
+			}, []),
+			cursor: S.data.cursor,
+			usedAuthorFeed: !0
+		};
+	} catch {}
+	let S = await callListRecords(e.pdsEndpoint, e.did, e.collection, e.limit, e.cursor);
+	if (!S.ok) throw Error("Failed to list records from PDS");
+	return {
+		records: S.data.records.filter((e) => isValidTimestamp(e.value)).map((e) => ({
+			uri: e.uri,
+			rkey: e.rkey ?? extractRkey(e.uri),
+			value: e.value
+		})),
+		cursor: S.data.cursor,
+		usedAuthorFeed: !1
+	};
+}
+function paginatedPageCacheKey(e) {
+	return JSON.stringify({
+		did: e.did,
+		collection: e.collection,
+		limit: e.limit,
+		cursor: e.cursor ?? "",
+		preferAuthorFeed: !!e.preferAuthorFeed,
+		authorFeedActor: e.authorFeedActor ?? "",
+		authorFeedService: e.authorFeedService,
+		authorFeedFilter: e.authorFeedFilter ?? "",
+		authorFeedIncludePins: !!e.authorFeedIncludePins
+	});
+}
+function primePaginatedRecordCache(e, x, S) {
+	let C = parseAtUriLoose(x);
+	if (!C) return;
+	let w = {
+		record: S,
+		source: "appview"
+	};
+	e.recordCache?.set(C.did, C.collection, C.rkey, w);
+}
+function primeAuthorProfileCache(e, x) {
+	if (!x?.did) return;
+	let S = {
+		record: appviewProfileToRecord(x),
+		source: "appview"
+	};
+	e.recordCache?.set(x.did, "app.bsky.actor.profile", "self", S);
+}
+function primeDidCache(e, x) {
+	x?.did && e.didCache?.memoize({
+		did: x.did,
+		handle: x.handle
+	});
+}
+function parseAtUriLoose(e) {
+	let x = e.match(/^at:\/\/([^/]+)\/([^/]+)\/([^/]+)$/);
+	if (x) return {
+		did: x[1],
+		collection: x[2],
+		rkey: x[3]
+	};
+}
+async function fetchFromAppview(x, S, C, w) {
+	let E = BLUESKY_COLLECTION_TO_ENDPOINT[S];
+	if (!E) throw Error(`No appview endpoint mapped for ${S}`);
+	let { rpc: D } = await createAtprotoClient({ service: w });
+	if (E === "app.bsky.actor.getProfile") {
+		let e = await D.get(E, { params: { actor: x } });
+		if (!e.ok) throw Error(`Appview ${E} failed for ${x}`);
+		return appviewProfileToRecord(e.data);
+	}
+	if (E === "app.bsky.feed.getPostThread") {
+		let e = `at://${x}/${S}/${C}`, w = await D.get(E, { params: {
+			uri: e,
+			depth: 0
+		} });
+		if (!w.ok) throw Error(`Appview ${E} failed for ${e}`);
+		let T = w.data.thread?.post;
+		return T?.record ? (mergePostEmbedCdnUrls(T.record, T.embed), T.record) : void 0;
+	}
+	throw Error(`Appview endpoint ${E} not implemented`);
+}
+function appviewProfileToRecord(e) {
+	let x = {
+		displayName: e.displayName,
+		description: e.description,
+		createdAt: e.createdAt
+	};
+	e.pronouns && (x.pronouns = e.pronouns), e.website && (x.website = e.website);
+	let S = extractCidFromCdnUrl(e.avatar), C = extractCidFromCdnUrl(e.banner);
+	return e.avatar && S && (x.avatar = appviewBlob(S, e.avatar)), e.banner && C && (x.banner = appviewBlob(C, e.banner)), x;
+}
+function appviewBlob(e, x) {
+	return {
+		$type: "blob",
+		ref: { $link: e },
+		mimeType: "image/jpeg",
+		size: 0,
+		cdnUrl: x
+	};
+}
+function mergePostEmbedCdnUrls(e, x) {
+	if (!x || typeof e != "object" || !e) return;
+	let S = e.embed;
+	if (!S) return;
+	let C = x.$type === "app.bsky.embed.recordWithMedia#view" ? x.media?.images : x.images, T = x.$type === "app.bsky.embed.recordWithMedia#view" ? S.media?.images : S.images;
+	!C || !T || T.forEach((e, x) => {
+		let S = C[x]?.fullsize;
+		if (!S) return;
+		let T = extractCidFromCdnUrl(S), E = e.image ?? {}, D = E.ref;
+		e.image = {
+			...E,
+			cdnUrl: S,
+			ref: { $link: T ?? D?.$link }
+		};
+	});
+}
+function extractRkey(e) {
+	let x = e.split("/");
+	return x[x.length - 1] ?? e;
+}
+function isValidTimestamp(e) {
+	if (typeof e != "object" || !e) return !0;
+	let x = e, S = x.createdAt || x.indexedAt;
+	if (!S || typeof S != "string") return !0;
+	let C = new Date(S);
+	return Number.isNaN(C.valueOf()) ? !0 : C.getFullYear() >= 2023;
+}
+export { ensureCachedRecord, extractRkey, fetchBlueskyRecord, fetchBlueskyRecordUncached, fetchLatestRecord, fetchPaginatedRecordsPage, fetchRepositoryRecord, getBlueskyRecord, isValidTimestamp, primeBlueskyFeedCache, primeBlueskyProfileCache };

package/dist/rpc.d.ts

@@ -0,0 +1,21 @@
+export declare function callAppviewRpc<TResponse>(service: string, nsid: string, params: Record<string, unknown>): Promise<{
+    ok: boolean;
+    data: TResponse;
+}>;
+export declare function callGetRecord<T>(service: string, did: string, collection: string, rkey: string): Promise<{
+    ok: boolean;
+    data: {
+        value: T;
+    };
+}>;
+export declare function callListRecords<T>(service: string, did: string, collection: string, limit: number, cursor?: string): Promise<{
+    ok: boolean;
+    data: {
+        records: Array<{
+            uri: string;
+            rkey?: string;
+            value: T;
+        }>;
+        cursor?: string;
+    };
+}>;

package/dist/rpc.js

@@ -0,0 +1,24 @@
+import { createAtprotoClient } from "./client.js";
+async function callAppviewRpc(t, n, r) {
+	let { rpc: i } = await createAtprotoClient({ service: t });
+	return await i.get(n, { params: r });
+}
+async function callGetRecord(t, n, r, i) {
+	let { rpc: a } = await createAtprotoClient({ service: t });
+	return await a.get("com.atproto.repo.getRecord", { params: {
+		repo: n,
+		collection: r,
+		rkey: i
+	} });
+}
+async function callListRecords(t, n, r, i, a) {
+	let { rpc: o } = await createAtprotoClient({ service: t });
+	return await o.get("com.atproto.repo.listRecords", { params: {
+		repo: n,
+		collection: r,
+		limit: i,
+		cursor: a,
+		reverse: !1
+	} });
+}
+export { callAppviewRpc, callGetRecord, callListRecords };

package/dist/styles.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Shared, framework-agnostic component styles.
+ *
+ * This is the single source of truth for how AtProto UI components look. React
+ * consumes the camelCase objects directly via `style={...}`; Solid and Svelte
+ * use {@link styleString} to render the same values as a `style="..."` string.
+ * Theme colors are referenced via CSS variables (see the theme tokens shipped in
+ * each package's styles.css) so light/dark theming works uniformly.
+ */
+export type StyleObject = Record<string, string | number>;
+/** Serializes a camelCase style object into a CSS `style="..."` string. */
+export declare function styleString(style: StyleObject): string;
+/** Merges style objects (later wins), for conditional overrides. */
+export declare function mergeStyles(...styles: (StyleObject | undefined | false)[]): StyleObject;
+/** Bluesky profile card. */
+export declare const profileStyles: Record<string, StyleObject>;
+/** Bluesky post card (standalone look). */
+export declare const postStyles: Record<string, StyleObject>;
+/** Bluesky author-feed list (matches React BlueskyPostList). */
+export declare const blueskyPostListStyles: Record<string, StyleObject>;
+/** Generic card + state primitives shared by the simpler record components. */
+export declare const cardStyles: Record<string, StyleObject>;
+/** Tangled repo card (matches React TangledRepoRenderer). */
+export declare const tangledStyles: Record<string, StyleObject>;
+/** Tangled string snippet card (matches React TangledStringRenderer). */
+export declare const tangledStringStyles: Record<string, StyleObject>;
+/** Leaflet document. */
+export declare const leafletStyles: Record<string, StyleObject>;
+/** grain.social gallery. */
+export declare const grainStyles: Record<string, StyleObject>;
+/** teal.fm currently-playing / last-played / song history. */
+export declare const tealStyles: Record<string, StyleObject>;
+/** teal.fm now-playing card (matches React CurrentlyPlayingRenderer). */
+export declare const tealStatusStyles: Record<string, StyleObject>;
+/** teal.fm song history list (matches React SongHistoryList). */
+export declare const songHistoryStyles: Record<string, StyleObject>;
+/** grain.social gallery card (matches React GrainGalleryRenderer). */
+export declare const grainGalleryStyles: Record<string, StyleObject>;
+/** Leaflet document (matches React LeafletDocumentRenderer). */
+export declare const leafletDocStyles: Record<string, StyleObject>;