commit ebd04c343095da4fbdf81118a16dc4660f9d4f8c · juli.ee/cleanfollow

+61 -39
src/App.tsx
···

       4
       4
        
       import { BskyAgent } from "@atproto/api";

     

       5
       5
        
       

     

       6
       6
        
       const [unfollowNotice, setUnfollowNotice] = createSignal("");

     

       7
       7
       +
       let unfollowURIs: number[] = [];

     

       8
       8
       +
       let followRecords: any[];

     

       7
       9
        
       

     

       8
       10
        
       const fetchFollows = async (agent: any) => {

     

       9
       11
        
         const PAGE_LIMIT = 100;

     
···

       31
       33
        
         userHandle: any,

     

       32
       34
        
         userPassword: any,

     

       33
       35
        
         serviceURL: any,

     

       36
       36
       +
         preview: boolean,

     

       34
       37
        
       ) => {

     

       35
       38
        
         setUnfollowNotice("");

     

       36
       39
        
       

     
···

       43
       46
        
           password: userPassword,

     

       44
       47
        
         });

     

       45
       48
        
       

     

       46
       46
       -
         const followRecords = await fetchFollows(agent);

     

       49
       49
       +
         if (!unfollowURIs.length) {

     

       50
       50
       +
           followRecords = await fetchFollows(agent);

     

       47
       51
        
       

     

       48
       48
       -
         let followsDID: string[] = [];

     

       49
       49
       -
         for (let n = 0; n < followRecords.length; n++)

     

       50
       50
       -
           followsDID[n] = followRecords[n].value.subject;

     

       52
       52
       +
           let followsDID: string[] = [];

     

       53
       53
       +
           for (let n = 0; n < followRecords.length; n++)

     

       54
       54
       +
             followsDID[n] = followRecords[n].value.subject;

     

       51
       55
        
       

     

       52
       52
       -
         for (let n = 0; n < followsDID.length; n = n + 25) {

     

       53
       53
       -
           const res = await agent.getProfiles({

     

       54
       54
       -
             actors: followsDID.slice(n, n + 25),

     

       55
       55
       -
           });

     

       56
       56
       +
           for (let n = 0; n < followsDID.length; n = n + 25) {

     

       57
       57
       +
             const res = await agent.getProfiles({

     

       58
       58
       +
               actors: followsDID.slice(n, n + 25),

     

       59
       59
       +
             });

     

       56
       60
        
       

     

       57
       57
       -
           let tmpDID: string[] = [];

     

       58
       58
       -
           for (let i = 0; i < res.data.profiles.length; i++) {

     

       59
       59
       -
             tmpDID[i] = res.data.profiles[i].did;

     

       60
       60
       -
             if (res.data.profiles[i].viewer?.blockedBy) {

     

       61
       61
       -
               await agent.deleteFollow(followRecords[i + n].uri);

     

       62
       62
       -
               console.log(

     

       63
       63
       -
                 "Unfollowed blocked account: " + followRecords[i + n].value.subject,

     

       64
       64
       -
                 " (" + res.data.profiles[i].handle + ")",

     

       65
       65
       -
               );

     

       66
       66
       -
               setUnfollowNotice(

     

       67
       67
       -
                 unfollowNotice() +

     

       68
       68
       -
                   "Unfollowed blocked account: " +

     

       69
       69
       -
                   followRecords[i + n].value.subject +

     

       70
       70
       -
                   " (" +

     

       71
       71
       -
                   res.data.profiles[i].handle +

     

       72
       72
       -
                   ")<br>",

     

       73
       73
       -
               );

     

       61
       61
       +
             let tmpDID: string[] = [];

     

       62
       62
       +
             for (let i = 0; i < res.data.profiles.length; i++) {

     

       63
       63
       +
               tmpDID[i] = res.data.profiles[i].did;

     

       64
       64
       +
               if (res.data.profiles[i].viewer?.blockedBy) {

     

       65
       65
       +
                 unfollowURIs.push(i + n);

     

       66
       66
       +
                 //await agent.deleteFollow(followRecords[i + n].uri);

     

       67
       67
       +
                 setUnfollowNotice(

     

       68
       68
       +
                   unfollowNotice() +

     

       69
       69
       +
                     "Found blocked account: " +

     

       70
       70
       +
                     followRecords[i + n].value.subject +

     

       71
       71
       +
                     " (" +

     

       72
       72
       +
                     res.data.profiles[i].handle +

     

       73
       73
       +
                     ")<br>",

     

       74
       74
       +
                 );

     

       75
       75
       +
               }

     

       74
       76
        
             }

     

       75
       75
       -
           }

     

       76
       76
       -
           for (let i = 0; i < res.data.profiles.length; i++) {

     

       77
       77
       -
             if (!tmpDID.includes(followsDID[i + n])) {

     

       78
       78
       -
               await agent.deleteFollow(followRecords[i + n].uri);

     

       79
       79
       -
               console.log(

     

       80
       80
       -
                 "Unfollowed deleted account: " + followRecords[i + n].value.subject,

     

       81
       81
       -
               );

     

       82
       82
       -
               setUnfollowNotice(

     

       83
       83
       -
                 unfollowNotice() +

     

       84
       84
       -
                   "Unfollowed deleted account: " +

     

       85
       85
       -
                   followRecords[i + n].value.subject +

     

       86
       86
       -
                   "<br>",

     

       87
       87
       -
               );

     

       77
       77
       +
             for (let i = 0; i < res.data.profiles.length; i++) {

     

       78
       78
       +
               if (!tmpDID.includes(followsDID[i + n])) {

     

       79
       79
       +
                 unfollowURIs.push(i + n);

     

       80
       80
       +
                 //await agent.deleteFollow(followRecords[i + n].uri);

     

       81
       81
       +
                 setUnfollowNotice(

     

       82
       82
       +
                   unfollowNotice() +

     

       83
       83
       +
                     "Found deleted account: " +

     

       84
       84
       +
                     followRecords[i + n].value.subject +

     

       85
       85
       +
                     "<br>",

     

       86
       86
       +
                 );

     

       87
       87
       +
               }

     

       88
       88
        
             }

     

       89
       89
        
           }

     

       90
       90
       +
         }

     

       91
       91
       +
       

     

       92
       92
       +
         if (!preview) {

     

       93
       93
       +
           for (const i of unfollowURIs) {

     

       94
       94
       +
             await agent.deleteFollow(followRecords[i].uri);

     

       95
       95
       +
             setUnfollowNotice(

     

       96
       96
       +
               unfollowNotice() +

     

       97
       97
       +
                 "Unfollowed account: " +

     

       98
       98
       +
                 followRecords[i].value.subject +

     

       99
       99
       +
                 "<br>",

     

       100
       100
       +
             );

     

       101
       101
       +
           }

     

       102
       102
       +
           unfollowURIs = [];

     

       103
       103
       +
           followRecords = [];

     

       90
       104
        
         }

     

       91
       105
        
       

     

       92
       106
        
         setUnfollowNotice(unfollowNotice() + "Done");

     
···

       124
       138
        
               <button

     

       125
       139
        
                 type="button"

     

       126
       140
        
                 onclick={() =>

     

       127
       127
       -
                   unfollowBsky(userHandle(), appPassword(), serviceURL())

     

       141
       141
       +
                   unfollowBsky(userHandle(), appPassword(), serviceURL(), true)

     

       142
       142
       +
                 }

     

       143
       143
       +
               >

     

       144
       144
       +
                 Preview

     

       145
       145
       +
               </button>

     

       146
       146
       +
               <button

     

       147
       147
       +
                 type="button"

     

       148
       148
       +
                 onclick={() =>

     

       149
       149
       +
                   unfollowBsky(userHandle(), appPassword(), serviceURL(), false)

     

       128
       150
        
                 }

     

       129
       151
        
               >

     

       130
       152
        
                 Unfollow