Rename missed `state` -> `status` occurrences — radicle-explorer

Remove more unused patch and issue schemas

👉 Preview 👉 Workflow runs 👉 Branch on GitHub

 } from "./lib/project.js";
 import type {
   Config,
   CodeLocation,
   Range,
   SeedingPolicy,
   DefaultSeedingPolicy,
 } from "./lib/shared.js";

   Merge,
   Patch,
   PatchState,
   PatchUpdateAction,
   Review,
   Revision,
   Verdict,

   Blob,
   ChangesetWithDiff,
   ChangesetWithoutDiff,
   CodeLocation,
   Comment,
   Commit,
   CommitBlob,

   Merge,
   Patch,
   PatchState,
   PatchUpdateAction,
   Project,
   ProjectListQuery,
   Range,
   Reaction,
   Remote,
   Review,

     query?: {
       page?: number;
       perPage?: number;
       state?: string;
       status?: string;
     },
     options?: RequestOptions,
   ): Promise<Issue[]> {

 import type { Embed } from "./comment.js";
 import type { ZodSchema, z } from "zod";
 import { array, boolean, literal, object, string, union } from "zod";
 import { array, literal, object, string, union } from "zod";
 import { commentSchema } from "./comment.js";
 import { authorSchema } from "../shared.js";

 export type Issue = z.infer<typeof issueSchema>;
 export interface IssueCreated {
   success: boolean;
   id: string;
 }
 export const issueCreatedSchema = object({
   success: boolean(),
   id: string(),
 }) satisfies ZodSchema<IssueCreated>;
 export const issuesSchema = array(issueSchema) satisfies ZodSchema<Issue[]>;
 export type IssueUpdateAction =
   | { type: "edit"; title: string }
   | { type: "label"; labels: string[] }
   | {
       type: "assign";
       assignees: string[];
     }
   | { type: "lifecycle"; state: IssueState }
   | {
       type: "comment";
       body: string;
       embeds?: Embed[];
       replyTo?: string;
     }
   | {
       type: "comment.edit";
       id: string;
       body: string;
       embeds: Embed[];
     }
   | { type: "comment.redact"; id: string }
   | {
       type: "comment.react";
       id: string;
       reaction: string;
       active: boolean;
     };

   | { status: "draft" }
   | { status: "open" }
   | { status: "archived" };
 export type PatchUpdateAction =
   | { type: "edit"; title: string; target: "delegates" }
   | { type: "label"; labels: string[] }
   | { type: "assign"; assignees: string[] }
   | { type: "merge"; revision: string; commit: string }
   | { type: "lifecycle"; state: LifecycleState }
   | {
       type: "review";
       revision: string;
       summary?: string;
       verdict?: Verdict | null;
     }
   | { type: "review.edit"; review: string; summary?: string }
   | { type: "review.redact"; review: string }
   | {
       type: "review.comment";
       review: string;
       body: string;
       location: CodeLocation;
       replyTo?: string;
       embeds?: Embed[];
     }
   | {
       type: "review.comment.edit";
       review: string;
       comment: string;
       body: string;
       embeds: Embed[];
     }
   | {
       type: "review.comment.redact";
       review: string;
       comment: string;
     }
   | {
       type: "review.comment.react";
       review: string;
       comment: string;
       reaction: string;
       active: boolean;
     }
   | { type: "revision"; description: string; base: string; oid: string }
   | {
       type: "revision.edit";
       revision: string;
       description: string;
       embeds?: Embed[];
     }
   | {
       type: "revision.react";
       revision: string;
       reaction: string;
       location?: CodeLocation;
       active: boolean;
     }
   | { type: "revision.redact"; revision: string }
   | {
       type: "revision.comment";
       revision: string;
       body: string;
       embeds?: Embed[];
       location?: CodeLocation;
       replyTo?: string;
     }
   | {
       type: "revision.comment.edit";
       revision: string;
       comment: string;
       body: string;
       embeds: Embed[];
     }
   | {
       type: "revision.comment.redact";
       revision: string;
       comment: string;
     }
   | {
       type: "revision.comment.react";
       revision: string;
       comment: string;
       reaction: string;
       active: boolean;
     };
 export const patchCreateSchema = object({
   title: string(),
   description: string(),
   target: string(),
   oid: string(),
   labels: array(string()),
 });
 export type PatchCreate = z.infer<typeof patchCreateSchema>;
 export const patchCreatedSchema = object({
   success: boolean(),
   id: string(),
 });
 export type PatchCreated = z.infer<typeof patchCreatedSchema>;

 import { array, boolean, literal, number, object, string, union } from "zod";
 export interface SuccessResponse {
   success: true;
 }
 export const scopeSchema = union([literal("followed"), literal("all")]);
 export const seedingPolicySchema = union([

   new: rangeSchema.nullable(),
 });
 export type CodeLocation = z.infer<typeof codeLocationSchema>;
 export const authorSchema = object({
   id: string(),
   alias: string().optional(),

     await api.project.getAllIssues(cobRid, {
       page: 0,
       perPage: 5,
       state: "open",
       status: "open",
     });
   });

   export let seedingPolicy: SeedingPolicy;
   export let issues: Issue[];
   export let project: Project;
   export let state: IssueState["status"];
   export let status: IssueState["status"];
   let loading = false;
   let page = 0;

   const api = new HttpdClient(baseUrl);
   async function loadIssues(state: IssueState["status"]): Promise<void> {
   async function loadIssues(status: IssueState["status"]): Promise<void> {
     loading = true;
     page += 1;
     try {
       const response = await api.project.getAllIssues(project.id, {
         state,
         status,
         page,
         perPage: ISSUES_PER_PAGE,
       });

   };
   $: showMoreButton =
     !loading && !error && allIssues.length < project.issues[state];
     !loading && !error && allIssues.length < project.issues[status];
 </script>
 <style>

         on:click={toggle}
         ariaLabel="filter-dropdown"
         title="Filter issues by state">
         <div style:color={stateColor[state]}>
         <div style:color={stateColor[status]}>
           <IconSmall name="issue" />
         </div>
         {capitalize(state)}
         {capitalize(status)}
         <div class="dropdown-button-counter">
           {project.issues[state]}
           {project.issues[status]}
         </div>
         <IconSmall name={expanded ? "chevron-up" : "chevron-down"} />
       </Button>

             resource: "project.issues",
             project: project.id,
             node: baseUrl,
             state: item,
             status: item,
           }}>
           <DropdownListItem selected={item === state}>
           <DropdownListItem selected={item === status}>
             <div style:color={stateColor[item]}>
               <IconSmall name="issue" />
             </div>

               {capitalize(item)}
               <div
                 class="dropdown-list-counter"
                 class:selected={item === state}>
                 class:selected={item === status}>
                 {project.issues[item]}
               </div>
             </div>

       {error} />
   {/if}
   {#if project.issues[state] === 0}
   {#if project.issues[status] === 0}
     <div class="placeholder">
       <Placeholder iconName="no-issues" caption={`No ${state} issues`} />
       <Placeholder iconName="no-issues" caption={`No ${status} issues`} />
     </div>
   {/if}

         <Button
           size="large"
           variant="outline"
           on:click={() => loadIssues(state)}>
           on:click={() => loadIssues(status)}>
           More
         </Button>
       {/if}

   const api = new HttpdClient(baseUrl);
   async function loadMore(state: PatchState["status"]): Promise<void> {
   async function loadMore(status: PatchState["status"]): Promise<void> {
     loading = true;
     page += 1;
     try {
       const response = await api.project.getAllPatches(project.id, {
         state,
         status,
         page,
         perPage: PATCHES_PER_PAGE,
       });

       {error} />
   {/if}
   {#if project.patches[state] === 0}
   {#if project.patches[status] === 0}
     <div class="placeholder">
       <Placeholder iconName="no-patches" caption={`No ${state} patches`} />
       <Placeholder iconName="no-patches" caption={`No ${status} patches`} />
     </div>
   {/if}

   resource: "project.issues";
   node: BaseUrl;
   project: string;
   state?: "open" | "closed";
   status?: "open" | "closed";
 }
 interface ProjectIssueRoute {

         seedingPolicy: SeedingPolicy;
         project: Project;
         patches: Patch[];
         state: PatchState["status"];
         status: PatchState["status"];
       };
     }
   | {

 ): Promise<ProjectLoadedRoute> {
   const api = new HttpdClient(route.node);
   const searchParams = new URLSearchParams(route.search || "");
   const state = (searchParams.get("state") as PatchState["status"]) || "open";
   const status = (searchParams.get("status") as PatchState["status"]) || "open";
   const [project, patches, seedingPolicy] = await Promise.all([
     api.project.getById(route.project),
     api.project.getAllPatches(route.project, {
       state,
       status,
       page: 0,
       perPage: PATCHES_PER_PAGE,
     }),

       baseUrl: route.node,
       seedingPolicy,
       issues,
       state,
       status,
       project,
     },
   };

         issue: issueOrAction,
       };
     } else {
       const rawState = new URLSearchParams(sanitizeQueryString(urlSearch)).get(
         "state",
       const rawStatus = new URLSearchParams(sanitizeQueryString(urlSearch)).get(
         "status",
       );
       let state: "open" | "closed" | undefined;
       if (rawState === "open" || rawState === "closed") {
         state = rawState;
       let status: "open" | "closed" | undefined;
       if (rawStatus === "open" || rawStatus === "closed") {
         status = rawStatus;
       }
       return {
         resource: "project.issues",
         node,
         project,
         state,
         status,
       };
     }
   } else if (content === "patches") {

   } else if (route.resource === "project.issues") {
     let url = [...pathSegments, "issues"].join("/");
     const searchParams = new URLSearchParams();
     if (route.state) {
       searchParams.set("state", route.state);
     if (route.status) {
       searchParams.set("status", route.status);
     }
     if (searchParams.size > 0) {
       url += `?${searchParams}`;

   await page.getByRole("button", { name: "filter-dropdown" }).first().click();
   await page.getByRole("link", { name: "Closed 2" }).click();
   await expect(page).toHaveURL(`${cobUrl}/issues?state=closed`);
   await expect(page).toHaveURL(`${cobUrl}/issues?status=closed`);
 });
 test("issue counters", async ({ page, peer }) => {

   await page.getByRole("button", { name: "filter-dropdown" }).first().click();
   await page.getByRole("link", { name: "Merged 1" }).click();
   await expect(page).toHaveURL(`${cobUrl}/patches?state=merged`);
   await expect(page).toHaveURL(`${cobUrl}/patches?status=merged`);
   await expect(
     page.locator(".comments").filter({ hasText: "5" }),
   ).toBeVisible();

     });
   });
   test("projects.issues with state", () => {
   test("projects.issues with status", () => {
     expectParsingInvariant({
       resource: "project.issues",
       node,
       project: "PROJECT",
       state: "closed",
       status: "closed",
     });
   });

   await page.goto(`${cobUrl}/issues`, { waitUntil: "networkidle" });
   await expect(page).toHaveScreenshot({ fullPage: true });
   await page.goto(`${cobUrl}/issues?state=closed`, {
   await page.goto(`${cobUrl}/issues?status=closed`, {
     waitUntil: "networkidle",
   });
   await expect(page).toHaveScreenshot({ fullPage: true });

     ["A closed issue", "closed"],
     ["A solved issue", "closed"],
   ];
   for (const [name, state] of issues) {
     await page.goto(`${cobUrl}/issues?state=${state}`);
   for (const [name, status] of issues) {
     await page.goto(`${cobUrl}/issues?status=${status}`);
     await page.getByRole("link", { name }).click();
     await page.getByRole("heading", { name }).waitFor();
     await expect(page).toHaveScreenshot({ fullPage: true });

     ["Taking another stab at the README", "open"],
   ];
   for (const [name, state] of patches) {
     await page.goto(`${cobUrl}/patches?state=${state}`);
   for (const [name, status] of patches) {
     await page.goto(`${cobUrl}/patches?status=${status}`);
     await page.getByRole("link", { name }).click();
     await page.getByRole("heading", { name }).waitFor();
     await expect(page).toHaveScreenshot({ fullPage: true });