commit 13043209a47bb2afe1a968f438c9511289527296 · indexx.dev/plc-bench

+38 -5
src/pages/Index.tsx
···

       13
       13
        
         const [loading, setLoading] = useState(false);

     

       14
       14
        
         const [results, setResults] = useState<BenchmarkResult[]>([]);

     

       15
       15
        
       

     

       16
       16
       +
         const resolveHandle = async (handle: string): Promise<string | null> => {

     

       17
       17
       +
           try {

     

       18
       18
       +
             const response = await fetch(

     

       19
       19
       +
               `https://quickdid.smokesignal.tools/xrpc/com.atproto.identity.resolveHandle?handle=${encodeURIComponent(handle)}`

     

       20
       20
       +
             );

     

       21
       21
       +
             const data = await response.json();

     

       22
       22
       +
             

     

       23
       23
       +
             if (data.error) {

     

       24
       24
       +
               toast.error(`Unable to resolve handle: ${data.message || "Invalid handle"}`);

     

       25
       25
       +
               return null;

     

       26
       26
       +
             }

     

       27
       27
       +
             

     

       28
       28
       +
             return data.did;

     

       29
       29
       +
           } catch (error) {

     

       30
       30
       +
             toast.error("Failed to resolve handle");

     

       31
       31
       +
             console.error(error);

     

       32
       32
       +
             return null;

     

       33
       33
       +
           }

     

       34
       34
       +
         };

     

       35
       35
       +
       

     

       16
       36
        
         const handleBenchmark = async () => {

     

       17
       37
        
           if (!did.trim()) {

     

       18
       18
       -
             toast.error("Please enter a DID");

     

       38
       38
       +
             toast.error("Please enter a DID or handle");

     

       19
       39
        
             return;

     

       20
       40
        
           }

     

       21
       41
        
       

     
···

       23
       43
        
           setResults([]);

     

       24
       44
        
       

     

       25
       45
        
           try {

     

       26
       26
       -
             const benchmarkResults = await benchmarkAllMirrors(mirrors, did.trim());

     

       46
       46
       +
             let resolvedDid = did.trim();

     

       47
       47
       +
             

     

       48
       48
       +
             // If input doesn't start with "did:plc", treat it as a handle

     

       49
       49
       +
             if (!resolvedDid.startsWith("did:plc")) {

     

       50
       50
       +
               const resolved = await resolveHandle(resolvedDid);

     

       51
       51
       +
               if (!resolved) {

     

       52
       52
       +
                 setLoading(false);

     

       53
       53
       +
                 return;

     

       54
       54
       +
               }

     

       55
       55
       +
               resolvedDid = resolved;

     

       56
       56
       +
               toast.success(`Resolved to ${resolvedDid}`);

     

       57
       57
       +
             }

     

       58
       58
       +
       

     

       59
       59
       +
             const benchmarkResults = await benchmarkAllMirrors(mirrors, resolvedDid);

     

       27
       60
        
             setResults(benchmarkResults);

     

       28
       61
        
             

     

       29
       62
        
             const successCount = benchmarkResults.filter(r => r.status === "success").length;

     
···

       61
       94
        
                 <div className="space-y-4">

     

       62
       95
        
                   <div>

     

       63
       96
        
                     <label htmlFor="did-input" className="block text-sm font-medium mb-2">

     

       64
       64
       -
                       ATProto DID

     

       97
       97
       +
                       ATProto DID or Handle

     

       65
       98
        
                     </label>

     

       66
       99
        
                     <div className="flex gap-3">

     

       67
       100
        
                       <Input

     

       68
       101
        
                         id="did-input"

     

       69
       102
        
                         type="text"

     

       70
       70
       -
                         placeholder="did:plc:example123..."

     

       103
       103
       +
                         placeholder="did:plc:example123... or handle.bsky.social"

     

       71
       104
        
                         value={did}

     

       72
       105
        
                         onChange={(e) => setDid(e.target.value)}

     

       73
       106
        
                         onKeyPress={handleKeyPress}

     
···

       110
       143
        
                 <div className="bg-muted/30 border border-border rounded-lg p-6">

     

       111
       144
        
                   <h3 className="font-semibold mb-2">How to use:</h3>

     

       112
       145
        
                   <ol className="list-decimal list-inside space-y-1 text-sm text-muted-foreground">

     

       113
       113
       -
                     <li>Enter an ATProto DID (e.g., did:plc:z72i7hdynmk6r22z27h6tvur)</li>

     

       146
       146
       +
                     <li>Enter an ATProto DID or handle (e.g., did:plc:z72i7hdynmk6r22z27h6tvur or handle.bsky.social)</li>

     

       114
       147
        
                     <li>Click "Run Benchmark" or press Enter</li>

     

       115
       148
        
                     <li>View response times and status for each mirror</li>

     

       116
       149
        
                   </ol>