···

       
59
       
 
       
    }

     

       
60
       
 
       


     

       
61
       
 
       
    const didDocument = await didDocPromise;

     

       
62
       
-
       


     

       
63
       
 
       
    const pdsEndpoint = getPdsEndpoint(didDocument);

     

       
64
       
 
       


     

       
65
       
 
       
    if (!pdsEndpoint) {

     
···

       
199
       
 
       
  const [validSchema, setValidSchema] = createSignal<boolean | undefined>(undefined);

     

       
200
       
 
       
  const [schema, setSchema] = createSignal<ResolvedSchema>();

     

       
201
       
 
       
  const [lexiconNotFound, setLexiconNotFound] = createSignal<boolean>();

     

       
0
       
 
       

     

       
202
       
 
       
  const did = params.repo;

     

       
203
       
 
       
  let rpc: Client;

     

       
204
       
 
       


     
···

       
250
       
 
       


     

       
251
       
 
       
  const validateRemoteSchema = async (record: Record<string, unknown>) => {

     

       
252
       
 
       
    try {

     

       
0
       
 
       

     

       
253
       
 
       
      const { resolved, failed } = await resolveAllLexicons(params.collection as Nsid);

     

       
254
       
 
       


     

       
255
       
 
       
      if (failed.size > 0) {

     
···

       
274
       
 
       
      setValidSchema(false);

     

       
275
       
 
       
      setValidationError(err.message || String(err));

     

       
276
       
 
       
    }

     

       
0
       
 
       

     

       
277
       
 
       
  };

     

       
278
       
 
       


     

       
279
       
 
       
  const verifyRecordIntegrity = async () => {

     
···

       
518
       
 
       
                ></span>

     

       
519
       
 
       
              </div>

     

       
520
       
 
       
              <Show when={validRecord() === false}>

     

       
521
       
-
       
                <div class="wrap-break-word">{verifyError()}</div>

     

       
522
       
 
       
              </Show>

     

       
523
       
 
       
            </div>

     

       
524
       
 
       
            <div>

     
···

       
530
       
 
       
                    "iconify lucide--check text-green-500 dark:text-green-400":

     

       
531
       
 
       
                      validSchema() === true,

     

       
532
       
 
       
                    "iconify lucide--x text-red-500 dark:text-red-400": validSchema() === false,

     

       
533
       
-
       
                    "iconify lucide--loader-circle animate-spin": validSchema() === undefined,

     

       
0
       
 
       

     

       
534
       
 
       
                  }}

     

       
535
       
 
       
                ></span>

     

       
536
       
 
       
              </div>

     

       
537
       
 
       
              <Show when={validSchema() === false}>

     

       
538
       
-
       
                <div class="wrap-break-word">{validationError()}</div>

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
539
       
 
       
              </Show>

     

       
540
       
 
       
            </div>

     

       
541
       
 
       
            <Show when={lexiconUri()}>

     

···

       
59
       
 
       
    }

     

       
60
       
 
       


     

       
61
       
 
       
    const didDocument = await didDocPromise;

     

       
0
       
 
       

     

       
62
       
 
       
    const pdsEndpoint = getPdsEndpoint(didDocument);

     

       
63
       
 
       


     

       
64
       
 
       
    if (!pdsEndpoint) {

     
···

       
198
       
 
       
  const [validSchema, setValidSchema] = createSignal<boolean | undefined>(undefined);

     

       
199
       
 
       
  const [schema, setSchema] = createSignal<ResolvedSchema>();

     

       
200
       
 
       
  const [lexiconNotFound, setLexiconNotFound] = createSignal<boolean>();

     

       
201
       
+
       
  const [remoteValidation, setRemoteValidation] = createSignal<boolean>();

     

       
202
       
 
       
  const did = params.repo;

     

       
203
       
 
       
  let rpc: Client;

     

       
204
       
 
       


     
···

       
250
       
 
       


     

       
251
       
 
       
  const validateRemoteSchema = async (record: Record<string, unknown>) => {

     

       
252
       
 
       
    try {

     

       
253
       
+
       
      setRemoteValidation(true);

     

       
254
       
 
       
      const { resolved, failed } = await resolveAllLexicons(params.collection as Nsid);

     

       
255
       
 
       


     

       
256
       
 
       
      if (failed.size > 0) {

     
···

       
275
       
 
       
      setValidSchema(false);

     

       
276
       
 
       
      setValidationError(err.message || String(err));

     

       
277
       
 
       
    }

     

       
278
       
+
       
    setRemoteValidation(false);

     

       
279
       
 
       
  };

     

       
280
       
 
       


     

       
281
       
 
       
  const verifyRecordIntegrity = async () => {

     
···

       
520
       
 
       
                ></span>

     

       
521
       
 
       
              </div>

     

       
522
       
 
       
              <Show when={validRecord() === false}>

     

       
523
       
+
       
                <div class="text-xs wrap-break-word">{verifyError()}</div>

     

       
524
       
 
       
              </Show>

     

       
525
       
 
       
            </div>

     

       
526
       
 
       
            <div>

     
···

       
532
       
 
       
                    "iconify lucide--check text-green-500 dark:text-green-400":

     

       
533
       
 
       
                      validSchema() === true,

     

       
534
       
 
       
                    "iconify lucide--x text-red-500 dark:text-red-400": validSchema() === false,

     

       
535
       
+
       
                    "iconify lucide--loader-circle animate-spin":

     

       
536
       
+
       
                      validSchema() === undefined && remoteValidation(),

     

       
537
       
 
       
                  }}

     

       
538
       
 
       
                ></span>

     

       
539
       
 
       
              </div>

     

       
540
       
 
       
              <Show when={validSchema() === false}>

     

       
541
       
+
       
                <div class="text-xs wrap-break-word">{validationError()}</div>

     

       
542
       
+
       
              </Show>

     

       
543
       
+
       
              <Show

     

       
544
       
+
       
                when={

     

       
545
       
+
       
                  !remoteValidation() &&

     

       
546
       
+
       
                  validSchema() === undefined &&

     

       
547
       
+
       
                  params.collection &&

     

       
548
       
+
       
                  !(params.collection in lexicons)

     

       
549
       
+
       
                }

     

       
550
       
+
       
              >

     

       
551
       
+
       
                <Button onClick={() => validateRemoteSchema(record()!.value)}>

     

       
552
       
+
       
                  Validate remotely

     

       
553
       
+
       
                </Button>

     

       
554
       
 
       
              </Show>

     

       
555
       
 
       
            </div>

     

       
556
       
 
       
            <Show when={lexiconUri()}>