···

       
11
       
 
       
  resolveFromIdentity,

     

       
12
       
 
       
  type Session,

     

       
13
       
 
       
} from "@atcute/oauth-browser-client";

     

       
14
       
-
       
import { $type, Did, Handle } from "@atcute/lexicons";

     

       
15
       
 
       
import { ComAtprotoRepoApplyWrites } from "@atcute/atproto";

     

       
16
       
 
       
import { AppBskyGraphFollow } from "@atcute/bluesky";

     

       
17
       
 
       


     
···

       
47
       
 
       
let rpc: Client;

     

       
48
       
 
       
let agent: OAuthUserAgent;

     

       
49
       
 
       
let manager: CredentialManager;

     

       
0
       
 
       

     

       
50
       
 
       


     

       
51
       
 
       
const resolveDid = async (did: string) => {

     

       
52
       
 
       
  const res = await fetch(

     
···

       
112
       
 
       
    if (session) {

     

       
113
       
 
       
      agent = new OAuthUserAgent(session);

     

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

     

       
0
       
 
       

     

       
115
       
 
       


     

       
116
       
 
       
      setLoginState(true);

     

       
117
       
 
       
      setHandle(await resolveDid(agent.sub));

     
···

       
149
       
 
       


     

       
150
       
 
       
  const loginBsky = async (login: string) => {

     

       
151
       
 
       
    if (password()) {

     

       
152
       
-
       
      const agentDID = login.startsWith("did:") ? login : await resolveHandle(login);

     

       
153
       
 
       
      manager = new CredentialManager({ service: await getPDS(agentDID) });

     

       
154
       
 
       
      rpc = new Client({ handler: manager });

     

       
155
       
 
       


     
···

       
245
       
 
       
      const fetchPage = async (cursor?: string) => {

     

       
246
       
 
       
        return await rpc.get("com.atproto.repo.listRecords", {

     

       
247
       
 
       
          params: {

     

       
248
       
-
       
            repo: agent.sub,

     

       
249
       
 
       
            collection: "app.bsky.graph.follow",

     

       
250
       
 
       
            limit: PAGE_LIMIT,

     

       
251
       
 
       
            cursor: cursor,

     
···

       
306
       
 
       
              viewer.blocking || viewer.blockingByList ?

     

       
307
       
 
       
                RepoStatus.BLOCKEDBY | RepoStatus.BLOCKING

     

       
308
       
 
       
              : RepoStatus.BLOCKEDBY;

     

       
309
       
-
       
          } else if (res.data.did.includes(agent.sub)) {

     

       
310
       
 
       
            status = RepoStatus.YOURSELF;

     

       
311
       
 
       
          } else if (viewer.blocking || viewer.blockingByList) {

     

       
312
       
 
       
            status = RepoStatus.BLOCKING;

     
···

       
361
       
 
       
    for (let i = 0; i < writes.length; i += BATCHSIZE) {

     

       
362
       
 
       
      await rpc.post("com.atproto.repo.applyWrites", {

     

       
363
       
 
       
        input: {

     

       
364
       
-
       
          repo: agent.sub,

     

       
365
       
 
       
          writes: writes.slice(i, i + BATCHSIZE),

     

       
366
       
 
       
        },

     

       
367
       
 
       
      });

     

···

       
11
       
 
       
  resolveFromIdentity,

     

       
12
       
 
       
  type Session,

     

       
13
       
 
       
} from "@atcute/oauth-browser-client";

     

       
14
       
+
       
import { $type, ActorIdentifier, Did, Handle } from "@atcute/lexicons";

     

       
15
       
 
       
import { ComAtprotoRepoApplyWrites } from "@atcute/atproto";

     

       
16
       
 
       
import { AppBskyGraphFollow } from "@atcute/bluesky";

     

       
17
       
 
       


     
···

       
47
       
 
       
let rpc: Client;

     

       
48
       
 
       
let agent: OAuthUserAgent;

     

       
49
       
 
       
let manager: CredentialManager;

     

       
50
       
+
       
let agentDID: string;

     

       
51
       
 
       


     

       
52
       
 
       
const resolveDid = async (did: string) => {

     

       
53
       
 
       
  const res = await fetch(

     
···

       
113
       
 
       
    if (session) {

     

       
114
       
 
       
      agent = new OAuthUserAgent(session);

     

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

     

       
116
       
+
       
      agentDID = agent.sub;

     

       
117
       
 
       


     

       
118
       
 
       
      setLoginState(true);

     

       
119
       
 
       
      setHandle(await resolveDid(agent.sub));

     
···

       
151
       
 
       


     

       
152
       
 
       
  const loginBsky = async (login: string) => {

     

       
153
       
 
       
    if (password()) {

     

       
154
       
+
       
      agentDID = login.startsWith("did:") ? login : await resolveHandle(login);

     

       
155
       
 
       
      manager = new CredentialManager({ service: await getPDS(agentDID) });

     

       
156
       
 
       
      rpc = new Client({ handler: manager });

     

       
157
       
 
       


     
···

       
247
       
 
       
      const fetchPage = async (cursor?: string) => {

     

       
248
       
 
       
        return await rpc.get("com.atproto.repo.listRecords", {

     

       
249
       
 
       
          params: {

     

       
250
       
+
       
            repo: agentDID as ActorIdentifier,

     

       
251
       
 
       
            collection: "app.bsky.graph.follow",

     

       
252
       
 
       
            limit: PAGE_LIMIT,

     

       
253
       
 
       
            cursor: cursor,

     
···

       
308
       
 
       
              viewer.blocking || viewer.blockingByList ?

     

       
309
       
 
       
                RepoStatus.BLOCKEDBY | RepoStatus.BLOCKING

     

       
310
       
 
       
              : RepoStatus.BLOCKEDBY;

     

       
311
       
+
       
          } else if (res.data.did.includes(agentDID)) {

     

       
312
       
 
       
            status = RepoStatus.YOURSELF;

     

       
313
       
 
       
          } else if (viewer.blocking || viewer.blockingByList) {

     

       
314
       
 
       
            status = RepoStatus.BLOCKING;

     
···

       
363
       
 
       
    for (let i = 0; i < writes.length; i += BATCHSIZE) {

     

       
364
       
 
       
      await rpc.post("com.atproto.repo.applyWrites", {

     

       
365
       
 
       
        input: {

     

       
366
       
+
       
          repo: agentDID as ActorIdentifier,

     

       
367
       
 
       
          writes: writes.slice(i, i + BATCHSIZE),

     

       
368
       
 
       
        },

     

       
369
       
 
       
      });