···

       
11
       
 
       
import { Modal } from "./modal.jsx";

     

       
12
       
 
       
import { Button } from "./button.jsx";

     

       
13
       
 
       


     

       
14
       
-
       
export const RecordEditor = (props: { create: boolean; record?: any }) => {

     

       
15
       
 
       
  const navigate = useNavigate();

     

       
16
       
 
       
  const params = useParams();

     

       
17
       
 
       
  const [openDialog, setOpenDialog] = createSignal(false);

     
···

       
119
       
 
       
        }

     

       
120
       
 
       
      }

     

       
121
       
 
       
      setOpenDialog(false);

     

       
122
       
-
       
      window.location.reload();

     

       
123
       
 
       
    } catch (err: any) {

     

       
124
       
 
       
      setNotice(err.message);

     

       
125
       
 
       
    }

     

···

       
11
       
 
       
import { Modal } from "./modal.jsx";

     

       
12
       
 
       
import { Button } from "./button.jsx";

     

       
13
       
 
       


     

       
14
       
+
       
export const RecordEditor = (props: { create: boolean; record?: any; refetch?: any }) => {

     

       
15
       
 
       
  const navigate = useNavigate();

     

       
16
       
 
       
  const params = useParams();

     

       
17
       
 
       
  const [openDialog, setOpenDialog] = createSignal(false);

     
···

       
119
       
 
       
        }

     

       
120
       
 
       
      }

     

       
121
       
 
       
      setOpenDialog(false);

     

       
122
       
+
       
      props.refetch();

     

       
123
       
 
       
    } catch (err: any) {

     

       
124
       
 
       
      setNotice(err.message);

     

       
125
       
 
       
    }

     

···

       
8
       
 
       
  const [cursor, setCursor] = createSignal<string>();

     

       
9
       
 
       
  let rpc: Client;

     

       
10
       
 
       


     

       
11
       
-
       
  const listBlobs = (did: string, cursor: string | undefined) =>

     

       
12
       
-
       
    rpc.get("com.atproto.sync.listBlobs", {

     

       
0
       
 
       

     

       
13
       
 
       
      params: {

     

       
14
       
-
       
        did: did as `did:${string}:${string}`,

     

       
15
       
 
       
        limit: LIMIT,

     

       
16
       
-
       
        cursor: cursor,

     

       
17
       
 
       
      },

     

       
18
       
 
       
    });

     

       
19
       
-
       


     

       
20
       
-
       
  const fetchBlobs = async () => {

     

       
21
       
-
       
    if (!rpc) rpc = new Client({ handler: new CredentialManager({ service: props.pds }) });

     

       
22
       
-
       
    const res = await listBlobs(props.repo, cursor());

     

       
23
       
 
       
    if (!res.ok) throw new Error(res.data.error);

     

       
24
       
 
       
    if (!res.data.cids) return [];

     

       
25
       
 
       
    setCursor(res.data.cids.length < LIMIT ? undefined : res.data.cursor);

     

···

       
8
       
 
       
  const [cursor, setCursor] = createSignal<string>();

     

       
9
       
 
       
  let rpc: Client;

     

       
10
       
 
       


     

       
11
       
+
       
  const fetchBlobs = async () => {

     

       
12
       
+
       
    if (!rpc) rpc = new Client({ handler: new CredentialManager({ service: props.pds }) });

     

       
13
       
+
       
    const res = await rpc.get("com.atproto.sync.listBlobs", {

     

       
14
       
 
       
      params: {

     

       
15
       
+
       
        did: props.repo as `did:${string}:${string}`,

     

       
16
       
 
       
        limit: LIMIT,

     

       
17
       
+
       
        cursor: cursor(),

     

       
18
       
 
       
      },

     

       
19
       
 
       
    });

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
20
       
 
       
    if (!res.ok) throw new Error(res.data.error);

     

       
21
       
 
       
    if (!res.data.cids) return [];

     

       
22
       
 
       
    setCursor(res.data.cids.length < LIMIT ? undefined : res.data.cursor);

     

···

       
75
       
 
       
  let pds: string;

     

       
76
       
 
       
  let rpc: Client;

     

       
77
       
 
       


     

       
78
       
-
       
  const listRecords = (did: string, collection: string, cursor: string | undefined) =>

     

       
79
       
-
       
    rpc.get("com.atproto.repo.listRecords", {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
80
       
 
       
      params: {

     

       
81
       
 
       
        repo: did as ActorIdentifier,

     

       
82
       
-
       
        collection: collection as `${string}.${string}.${string}`,

     

       
83
       
 
       
        limit: LIMIT,

     

       
84
       
-
       
        cursor: cursor,

     

       
85
       
 
       
        reverse: reverse(),

     

       
86
       
 
       
      },

     

       
87
       
 
       
    });

     

       
88
       
-
       


     

       
89
       
-
       
  const fetchRecords = async () => {

     

       
90
       
-
       
    if (!pds) pds = await resolvePDS(did);

     

       
91
       
-
       
    if (!rpc) rpc = new Client({ handler: new CredentialManager({ service: pds }) });

     

       
92
       
-
       
    const res = await listRecords(did, params.collection, cursor());

     

       
93
       
 
       
    if (!res.ok) throw new Error(res.data.error);

     

       
94
       
 
       
    setCursor(res.data.records.length < LIMIT ? undefined : res.data.cursor);

     

       
95
       
 
       
    const tmpRecords: AtprotoRecord[] = [];

     

···

       
75
       
 
       
  let pds: string;

     

       
76
       
 
       
  let rpc: Client;

     

       
77
       
 
       


     

       
78
       
+
       
  const fetchRecords = async () => {

     

       
79
       
+
       
    if (!pds) pds = await resolvePDS(did);

     

       
80
       
+
       
    if (!rpc) rpc = new Client({ handler: new CredentialManager({ service: pds }) });

     

       
81
       
+
       
    const res = await rpc.get("com.atproto.repo.listRecords", {

     

       
82
       
 
       
      params: {

     

       
83
       
 
       
        repo: did as ActorIdentifier,

     

       
84
       
+
       
        collection: params.collection as `${string}.${string}.${string}`,

     

       
85
       
 
       
        limit: LIMIT,

     

       
86
       
+
       
        cursor: cursor(),

     

       
87
       
 
       
        reverse: reverse(),

     

       
88
       
 
       
      },

     

       
89
       
 
       
    });

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
90
       
 
       
    if (!res.ok) throw new Error(res.data.error);

     

       
91
       
 
       
    setCursor(res.data.records.length < LIMIT ? undefined : res.data.cursor);

     

       
92
       
 
       
    const tmpRecords: AtprotoRecord[] = [];

     

···

       
28
       
 
       
    setVersion((res.data as any).version);

     

       
29
       
 
       
  };

     

       
30
       
 
       


     

       
31
       
-
       
  const fetchRepos = async (): Promise<

     

       
32
       
-
       
    InferXRPCBodyOutput<ComAtprotoSyncListRepos.mainSchema["output"]>

     

       
33
       
-
       
  > => {

     

       
34
       
 
       
    await getVersion();

     

       
35
       
 
       
    const describeRes = await rpc.get("com.atproto.server.describeServer");

     

       
36
       
 
       
    if (!describeRes.ok) console.error(describeRes.data.error);

     

···

       
28
       
 
       
    setVersion((res.data as any).version);

     

       
29
       
 
       
  };

     

       
30
       
 
       


     

       
31
       
+
       
  const fetchRepos = async () => {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
32
       
 
       
    await getVersion();

     

       
33
       
 
       
    const describeRes = await rpc.get("com.atproto.server.describeServer");

     

       
34
       
 
       
    if (!describeRes.ok) console.error(describeRes.data.error);

     

···

       
1
       
 
       
import { CredentialManager, Client } from "@atcute/client";

     

       
2
       
 
       


     

       
3
       
 
       
import { useNavigate, useParams } from "@solidjs/router";

     

       
4
       
-
       
import { createSignal, ErrorBoundary, onMount, Show, Suspense } from "solid-js";

     

       
5
       
 
       


     

       
6
       
 
       
import { Backlinks } from "../components/backlinks.jsx";

     

       
7
       
 
       
import { JSONValue } from "../components/json.jsx";

     
···

       
11
       
 
       
import { didDocCache, resolvePDS } from "../utils/api.js";

     

       
12
       
 
       
import { AtUri, uriTemplates } from "../utils/templates.js";

     

       
13
       
 
       
import { verifyRecord } from "../utils/verify.js";

     

       
14
       
-
       
import { ActorIdentifier, InferXRPCBodyOutput, is } from "@atcute/lexicons";

     

       
15
       
 
       
import { lexiconDoc } from "@atcute/lexicon-doc";

     

       
16
       
-
       
import { ComAtprotoRepoGetRecord } from "@atcute/atproto";

     

       
17
       
 
       
import { lexicons } from "../utils/types/lexicons.js";

     

       
18
       
 
       
import { RecordEditor } from "../components/create.jsx";

     

       
19
       
 
       
import { addToClipboard } from "../utils/copy.js";

     
···

       
24
       
 
       
export const RecordView = () => {

     

       
25
       
 
       
  const navigate = useNavigate();

     

       
26
       
 
       
  const params = useParams();

     

       
27
       
-
       
  const [record, setRecord] =

     

       
28
       
-
       
    createSignal<InferXRPCBodyOutput<ComAtprotoRepoGetRecord.mainSchema["output"]>>();

     

       
29
       
 
       
  const [openDelete, setOpenDelete] = createSignal(false);

     

       
30
       
 
       
  const [notice, setNotice] = createSignal("");

     

       
31
       
 
       
  const [showBacklinks, setShowBacklinks] = createSignal(false);

     
···

       
35
       
 
       
  const did = params.repo;

     

       
36
       
 
       
  let rpc: Client;

     

       
37
       
 
       


     

       
38
       
-
       
  onMount(async () => {

     

       
39
       
 
       
    setCID(undefined);

     

       
40
       
 
       
    setValidRecord(undefined);

     

       
41
       
 
       
    setValidSchema(undefined);

     
···

       
53
       
 
       
      setNotice(res.data.error);

     

       
54
       
 
       
      throw new Error(res.data.error);

     

       
55
       
 
       
    }

     

       
56
       
-
       
    setRecord(res.data);

     

       
57
       
 
       
    setCID(res.data.cid);

     

       
58
       
 
       
    setExternalLink(checkUri(res.data.uri, res.data.value));

     

       
59
       
 
       


     
···

       
87
       
 
       
      console.error(err);

     

       
88
       
 
       
      setValidRecord(false);

     

       
89
       
 
       
    }

     

       
90
       
-
       
  });

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
91
       
 
       


     

       
92
       
 
       
  const deleteRecord = async () => {

     

       
93
       
 
       
    rpc = new Client({ handler: agent()! });

     
···

       
112
       
 
       
  };

     

       
113
       
 
       


     

       
114
       
 
       
  return (

     

       
115
       
-
       
    <div class="flex w-full flex-col items-center">

     

       
116
       
-
       
      <Show when={record() === undefined && validRecord() !== false}>

     

       
117
       
-
       
        <div class="iconify lucide--loader-circle mt-3 animate-spin text-xl" />

     

       
118
       
-
       
      </Show>

     

       
119
       
-
       
      <Show when={validRecord() === false}>

     

       
120
       
-
       
        <div class="mt-3 break-words text-red-500 dark:text-red-400">{notice()}</div>

     

       
121
       
-
       
      </Show>

     

       
122
       
-
       
      <Show when={record()}>

     

       
123
       
 
       
        <div class="dark:shadow-dark-900/80 dark:bg-dark-300 my-3 flex w-[22rem] justify-between rounded-lg bg-white px-2 py-1.5 shadow-sm sm:w-[24rem]">

     

       
124
       
 
       
          <div class="flex gap-3 text-sm">

     

       
125
       
 
       
            <button

     
···

       
147
       
 
       
          </div>

     

       
148
       
 
       
          <div class="flex gap-1">

     

       
149
       
 
       
            <Show when={agent() && agent()?.sub === record()?.uri.split("/")[2]}>

     

       
150
       
-
       
              <RecordEditor create={false} record={record()?.value} />

     

       
151
       
 
       
              <Tooltip text="Delete">

     

       
152
       
 
       
                <button

     

       
153
       
 
       
                  class="flex items-center rounded-sm p-1 hover:bg-neutral-100 active:bg-neutral-100 dark:hover:bg-neutral-600 dark:active:bg-neutral-600"

     
···

       
204
       
 
       
          </div>

     

       
205
       
 
       
        </div>

     

       
206
       
 
       
        <Show when={!showBacklinks()}>

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
207
       
 
       
          <div class="w-[22rem] font-mono text-xs wrap-anywhere whitespace-pre-wrap sm:w-full sm:text-sm">

     

       
208
       
 
       
            <JSONValue data={record()?.value as any} repo={record()!.uri.split("/")[2]} />

     

       
209
       
 
       
          </div>

     
···

       
219
       
 
       
            </Suspense>

     

       
220
       
 
       
          </ErrorBoundary>

     

       
221
       
 
       
        </Show>

     

       
222
       
-
       
      </Show>

     

       
223
       
-
       
    </div>

     

       
224
       
 
       
  );

     

       
225
       
 
       
};

     

···

       
1
       
 
       
import { CredentialManager, Client } from "@atcute/client";

     

       
2
       
 
       


     

       
3
       
 
       
import { useNavigate, useParams } from "@solidjs/router";

     

       
4
       
+
       
import { createResource, createSignal, ErrorBoundary, Show, Suspense } from "solid-js";

     

       
5
       
 
       


     

       
6
       
 
       
import { Backlinks } from "../components/backlinks.jsx";

     

       
7
       
 
       
import { JSONValue } from "../components/json.jsx";

     
···

       
11
       
 
       
import { didDocCache, resolvePDS } from "../utils/api.js";

     

       
12
       
 
       
import { AtUri, uriTemplates } from "../utils/templates.js";

     

       
13
       
 
       
import { verifyRecord } from "../utils/verify.js";

     

       
14
       
+
       
import { ActorIdentifier, is } from "@atcute/lexicons";

     

       
15
       
 
       
import { lexiconDoc } from "@atcute/lexicon-doc";

     

       
0
       
 
       

     

       
16
       
 
       
import { lexicons } from "../utils/types/lexicons.js";

     

       
17
       
 
       
import { RecordEditor } from "../components/create.jsx";

     

       
18
       
 
       
import { addToClipboard } from "../utils/copy.js";

     
···

       
23
       
 
       
export const RecordView = () => {

     

       
24
       
 
       
  const navigate = useNavigate();

     

       
25
       
 
       
  const params = useParams();

     

       
0
       
 
       

     

       
0
       
 
       

     

       
26
       
 
       
  const [openDelete, setOpenDelete] = createSignal(false);

     

       
27
       
 
       
  const [notice, setNotice] = createSignal("");

     

       
28
       
 
       
  const [showBacklinks, setShowBacklinks] = createSignal(false);

     
···

       
32
       
 
       
  const did = params.repo;

     

       
33
       
 
       
  let rpc: Client;

     

       
34
       
 
       


     

       
35
       
+
       
  const fetchRecord = async () => {

     

       
36
       
 
       
    setCID(undefined);

     

       
37
       
 
       
    setValidRecord(undefined);

     

       
38
       
 
       
    setValidSchema(undefined);

     
···

       
50
       
 
       
      setNotice(res.data.error);

     

       
51
       
 
       
      throw new Error(res.data.error);

     

       
52
       
 
       
    }

     

       
0
       
 
       

     

       
53
       
 
       
    setCID(res.data.cid);

     

       
54
       
 
       
    setExternalLink(checkUri(res.data.uri, res.data.value));

     

       
55
       
 
       


     
···

       
83
       
 
       
      console.error(err);

     

       
84
       
 
       
      setValidRecord(false);

     

       
85
       
 
       
    }

     

       
86
       
+
       


     

       
87
       
+
       
    return res.data;

     

       
88
       
+
       
  };

     

       
89
       
+
       


     

       
90
       
+
       
  const [record, { refetch }] = createResource(fetchRecord);

     

       
91
       
 
       


     

       
92
       
 
       
  const deleteRecord = async () => {

     

       
93
       
 
       
    rpc = new Client({ handler: agent()! });

     
···

       
112
       
 
       
  };

     

       
113
       
 
       


     

       
114
       
 
       
  return (

     

       
115
       
+
       
    <Show when={record()} keyed>

     

       
116
       
+
       
      <div class="flex w-full flex-col items-center">

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
117
       
 
       
        <div class="dark:shadow-dark-900/80 dark:bg-dark-300 my-3 flex w-[22rem] justify-between rounded-lg bg-white px-2 py-1.5 shadow-sm sm:w-[24rem]">

     

       
118
       
 
       
          <div class="flex gap-3 text-sm">

     

       
119
       
 
       
            <button

     
···

       
141
       
 
       
          </div>

     

       
142
       
 
       
          <div class="flex gap-1">

     

       
143
       
 
       
            <Show when={agent() && agent()?.sub === record()?.uri.split("/")[2]}>

     

       
144
       
+
       
              <RecordEditor create={false} record={record()?.value} refetch={refetch} />

     

       
145
       
 
       
              <Tooltip text="Delete">

     

       
146
       
 
       
                <button

     

       
147
       
 
       
                  class="flex items-center rounded-sm p-1 hover:bg-neutral-100 active:bg-neutral-100 dark:hover:bg-neutral-600 dark:active:bg-neutral-600"

     
···

       
198
       
 
       
          </div>

     

       
199
       
 
       
        </div>

     

       
200
       
 
       
        <Show when={!showBacklinks()}>

     

       
201
       
+
       
          <Show when={validRecord() === false}>

     

       
202
       
+
       
            <div class="mb-2 break-words text-red-500 dark:text-red-400">{notice()}</div>

     

       
203
       
+
       
          </Show>

     

       
204
       
 
       
          <div class="w-[22rem] font-mono text-xs wrap-anywhere whitespace-pre-wrap sm:w-full sm:text-sm">

     

       
205
       
 
       
            <JSONValue data={record()?.value as any} repo={record()!.uri.split("/")[2]} />

     

       
206
       
 
       
          </div>

     
···

       
216
       
 
       
            </Suspense>

     

       
217
       
 
       
          </ErrorBoundary>

     

       
218
       
 
       
        </Show>

     

       
219
       
+
       
      </div>

     

       
220
       
+
       
    </Show>

     

       
221
       
 
       
  );

     

       
222
       
 
       
};