commit c7941b02c2081aa3da9064837e491b70abc3837e · aylac.top/matted

+2 -1

biome.json

···

       16
       16
        
       		"enabled": true,

     

       17
       17
        
       		"rules": {

     

       18
       18
        
       			"recommended": true,

     

       19
       19
       -
       			"nursery": { "useSortedClasses": "warn" }

     

       19
       19
       +
       			"nursery": { "useSortedClasses": "warn" },

     

       20
       20
       +
       			"style": { "noNonNullAssertion": "off" }

     

       20
       21
        
       		},

     

       21
       22
        
       		"domains": {

     

       22
       23
        
       			"solid": "recommended"

+10 -14

src/routes/repo/blob.tsx

···

       4
       4
        
       	useNavigate,

     

       5
       5
        
       	useParams,

     

       6
       6
        
       } from "@solidjs/router";

     

       7
       7
       -
       import { Show, Suspense } from "solid-js";

     

       7
       7
       +
       import { Show } from "solid-js";

     

       8
       8
        
       import { CodeBlock } from "../../elements/code_block";

     

       9
       9
        
       import { getLanguage } from "../../util/get_language";

     

       10
       10
       +
       import { figureOutDid } from "../../util/handle";

     

       10
       11
        
       import { useDid } from "./context";

     

       11
       12
        
       import { Header } from "./main";

     

       12
       13
        
       import { getRepoBlob } from "./main.data";

     

       13
       13
       -
       import { figureOutDid } from "../../util/handle";

     

       14
       14
        
       

     

       15
       15
        
       export async function preloadRepoBlob({ params }: { params: Params }) {

     

       16
       16
       -
       	const did = await figureOutDid(params.user)

     

       16
       16
       +
       	const did = await figureOutDid(params.user);

     

       17
       17
        
       	if (!did) return;

     

       18
       18
        
       	getRepoBlob(did, params.repo, params.ref, params.path);

     

       19
       19
        
       }

     
···

       40
       40
        
       

     

       41
       41
        
       	return (

     

       42
       42
        
       		<div class="mx-auto max-w-5xl">

     

       43
       43
       -
       			<Show when={did()}>

     

       44
       44
       -
       				{(did) => <Header did={did()} user={params.user} repo={params.repo} />}

     

       45
       45
       -
       			</Show>

     

       46
       46
       -
       			<Suspense>

     

       43
       43
       +
       			<Header user={params.user} repo={params.repo} />

     

       44
       44
       +
       			<div class="flex flex-col rounded bg-white dark:bg-gray-800">

     

       47
       45
        
       				<Show when={blob()} keyed>

     

       48
       46
        
       					{(data) => (

     

       49
       49
       -
       						<div class="flex flex-col rounded bg-white dark:bg-gray-800">

     

       50
       50
       -
       							<CodeBlock

     

       51
       51
       -
       								code={data.content}

     

       52
       52
       -
       								language={getLanguage(data.path.split("/").pop()) || "text"}

     

       53
       53
       -
       							/>

     

       54
       54
       -
       						</div>

     

       47
       47
       +
       						<CodeBlock

     

       48
       48
       +
       							code={data.content}

     

       49
       49
       +
       							language={getLanguage(data.path.split("/").pop()) || "text"}

     

       50
       50
       +
       						/>

     

       55
       51
        
       					)}

     

       56
       52
        
       				</Show>

     

       57
       57
       -
       			</Suspense>

     

       53
       53
       +
       			</div>

     

       58
       54
        
       		</div>

     

       59
       55
        
       	);

     

       60
       56
        
       }

+4 -8

src/routes/repo/commit/commit.tsx

···

       237
       237
        
       }

     

       238
       238
        
       

     

       239
       239
        
       function CommitHeader(props: {

     

       240
       240
       -
       	did: DID;

     

       241
       240
        
       	user: string;

     

       242
       241
        
       	repo: string;

     

       243
       242
        
       	message: { title: string; content: string };

     
···

       245
       244
        
       }) {

     

       246
       245
        
       	return (

     

       247
       246
        
       		<div>

     

       248
       248
       -
       			<Header did={props.did} user={props.user} repo={props.repo} />

     

       247
       247
       +
       			<Header user={props.user} repo={props.repo} />

     

       249
       248
        
       			<div class="mx-1 flex flex-col gap-2 rounded bg-white p-4 dark:bg-gray-800">

     

       250
       249
        
       				<div>{props.message.title}</div>

     

       251
       250
        
       				<Show when={props.message.content}>

     
···

       310
       309
        
       

     

       311
       310
        
       	const headerData = createMemo(() => {

     

       312
       311
        
       		const c = commit();

     

       313
       313
       -
       		const d = did();

     

       314
       314
       -
       

     

       315
       315
       -
       		if (!(c && d)) return;

     

       312
       312
       +
       		if (!c) return;

     

       316
       313
        
       

     

       317
       314
        
       		const titleEnd = c.diff.commit.message.indexOf("\n");

     

       318
       315
        
       		const message = {

     
···

       320
       317
        
       			content: c.diff.commit.message.slice(titleEnd + 1),

     

       321
       318
        
       		};

     

       322
       319
        
       

     

       323
       323
       -
       		return [c, d, message] as const;

     

       320
       320
       +
       		return [c, message] as const;

     

       324
       321
        
       	});

     

       325
       322
        
       

     

       326
       323
        
       	onMount(() => {

     
···

       335
       332
        
       		<div class="mx-auto max-w-10xl">

     

       336
       333
        
       			<Suspense>

     

       337
       334
        
       				<Show when={headerData()} keyed>

     

       338
       338
       -
       					{([commit, did, message]) => (

     

       335
       335
       +
       					{([commit, message]) => (

     

       339
       336
        
       						<CommitHeader

     

       340
       340
       -
       							did={did}

     

       341
       337
        
       							user={params.user}

     

       342
       338
        
       							repo={params.repo}

     

       343
       339
        
       							message={message}

+1 -2

src/routes/repo/main.tsx

···

       1
       1
        
       import { type Accessor, createMemo, Show } from "solid-js";

     

       2
       2
       -
       import type { DID } from "../../util/types";

     

       3
       2
        
       import { useRepoInfo } from "./context";

     

       4
       3
        
       

     

       5
       4
        
       function HeaderItem(props: {

     
···

       19
       18
        
       	);

     

       20
       19
        
       }

     

       21
       20
        
       

     

       22
       22
       -
       export function Header(props: { did: DID; user: string; repo: string }) {

     

       21
       21
       +
       export function Header(props: { user: string; repo: string }) {

     

       23
       22
        
       	const repoInfo = useRepoInfo();

     

       24
       23
        
       	const path = createMemo(() => {

     

       25
       24
        
       		const path = window.location.pathname.split("/")[3];

+4 -8

src/routes/repo/tree.tsx

···

       99
       99
        
       	const [filesInOrder] = createResource(tree, (tree) => {

     

       100
       100
        
       		if (!tree.files) return;

     

       101
       101
        
       		return tree.files.sort((a, b) => {

     

       102
       102
       -
       			// Directories before files

     

       103
       102
        
       			if (!a.is_file === b.is_file) return !a.is_file ? -1 : 1;

     

       104
       103
        
       

     

       105
       105
       -
       			// Dotfiles first

     

       106
       104
        
       			const aDot = a.name.startsWith(".");

     

       107
       105
        
       			const bDot = b.name.startsWith(".");

     

       108
       106
        
       			if (aDot !== bDot) return aDot ? -1 : 1;

     

       109
       107
        
       

     

       110
       110
       -
       			// Name sorting (natural order)

     

       111
       108
        
       			return a.name.localeCompare(b.name, undefined, { numeric: true });

     

       112
       109
        
       		});

     

       113
       110
        
       	});

     
···

       115
       112
        
       	const repoData = createMemo(() => {

     

       116
       113
        
       		const db = defaultBranch();

     

       117
       114
        
       		const l = languages();

     

       118
       118
       -
       		const d = did();

     

       119
       119
       -
       		if (!(db && l && d)) return;

     

       120
       120
       -
       		return [db, l, d] as const;

     

       115
       115
       +
       		if (!(db && l)) return;

     

       116
       116
       +
       		return [db, l] as const;

     

       121
       117
        
       	});

     

       122
       118
        
       

     

       123
       119
        
       	const pathData = createMemo(() => {

     
···

       132
       128
        
       	return (

     

       133
       129
        
       		<div class="mx-auto max-w-5xl">

     

       134
       130
        
       			<Show when={repoData()} keyed>

     

       135
       135
       -
       				{([defaultBranch, languages, did]) => (

     

       131
       131
       +
       				{([defaultBranch, languages]) => (

     

       136
       132
        
       					<Show when={pathData()} keyed>

     

       137
       133
        
       						{([tree, files, readme, logs]) => (

     

       138
       134
        
       							<div>

     

       139
       139
       -
       								<Header did={did} user={params.user} repo={params.repo} />

     

       135
       135
       +
       								<Header user={params.user} repo={params.repo} />

     

       140
       136
        
       								<div class="mb-4 flex flex-col rounded bg-white dark:bg-gray-800">

     

       141
       137
        
       									<LanguageLine languages={languages} />

     

       142
       138
        
       									<div class="flex flex-row">

+13 -12

src/util/handle.ts

···

       24
       24
        
       export const figureOutDid = query(async (user: string): Promise<DID> => {

     

       25
       25
        
       	const isDid = user.startsWith("did:");

     

       26
       26
        
       	if (!isDid && user.includes(".")) {

     

       27
       27
       -
       		let res = didMap.get(user);

     

       28
       28
       -
       		if (!res && useSlingshot)

     

       29
       29
       -
       			res = (

     

       30
       30
       -
       				await (

     

       31
       31
       -
       					await fetch(

     

       32
       32
       -
       						`${slingshotUrl}/xrpc/com.atproto.identity.resolveHandle?handle=${user}`,

     

       33
       33
       -
       					)

     

       34
       34
       -
       				).json()

     

       35
       35
       -
       			).did;

     

       36
       36
       -
       		if (!res) res = await handleResolver.resolve(user as `${string}.${string}`);

     

       37
       37
       -
       		didMap.set(user, res);

     

       38
       38
       -
       		return res;

     

       27
       27
       +
       		let did = didMap.get(user);

     

       28
       28
       +
       		if (!did && useSlingshot) {

     

       29
       29
       +
       			const res = await fetch(

     

       30
       30
       +
       				`${slingshotUrl}/xrpc/com.atproto.identity.resolveHandle?handle=${user}`,

     

       31
       31
       +
       			);

     

       32
       32
       +
       			if (res.ok) {

     

       33
       33
       +
       				const json = await res.json();

     

       34
       34
       +
       				if ("did" in json && typeof json.did === "string") did = json.did;

     

       35
       35
       +
       			}

     

       36
       36
       +
       		}

     

       37
       37
       +
       		if (!did) did = await handleResolver.resolve(user as `${string}.${string}`);

     

       38
       38
       +
       		didMap.set(user, did);

     

       39
       39
       +
       		return did;

     

       39
       40
        
       	}

     

       40
       41
        
       	return user as DID;

     

       41
       42
        
       }, "handles");