Add support for submodules — radicle-explorer

Requires patch heartwood@3c8f7b94ec92f5759d6e4a51f3ddff403872e12a

👉 Preview
👉 Workflow runs
👉 Branch on GitHub

 const treeEntrySchema = object({
   path: string(),
   name: string(),
   kind: union([literal("blob"), literal("tree")]),
   oid: string(),
   kind: union([literal("blob"), literal("tree"), literal("submodule")]),
 });
 export type TreeEntry = z.infer<typeof treeEntrySchema>;

 import type { z } from "zod";
 import { array, boolean, number, object, string } from "zod";
 import { codeLocationSchema } from "../shared";
 import { authorSchema, codeLocationSchema } from "../shared";
 export type Comment = z.infer<typeof commentSchema>;
 export type Embed = z.infer<typeof commentSchema>["embeds"][0];
 export type Embed = Comment["embeds"][0];
 export type Reaction = Comment["reactions"][0];
 export const commentSchema = object({
   id: string(),
   author: object({ id: string(), alias: string().optional() }),
   author: authorSchema,
   body: string(),
   edits: array(
     object({
       author: object({ id: string(), alias: string().optional() }),
       author: authorSchema,
       body: string(),
       embeds: array(object({ name: string(), content: string() })),
       timestamp: number(),
     }),
   ),
   embeds: array(object({ name: string(), content: string() })),
   reactions: array(object({ emoji: string(), authors: array(string()) })),
   reactions: array(object({ emoji: string(), authors: array(authorSchema) })),
   timestamp: number(),
   location: codeLocationSchema.nullable().optional(),
   resolved: boolean(),

 import { array, boolean, literal, object, string, union } from "zod";
 import { commentSchema } from "./comment.js";
 import { authorSchema } from "../shared.js";
 export type IssueState =
   | { status: "open" }

 export const issueSchema = object({
   id: string(),
   author: object({ id: string(), alias: string().optional() }),
   author: authorSchema,
   title: string(),
   state: issueStateSchema,
   discussion: array(commentSchema),
   labels: array(string()),
   assignees: array(string()),
   assignees: array(authorSchema),
 });
 export type Issue = z.infer<typeof issueSchema>;

   tuple,
   union,
 } from "zod";
 import { codeLocationSchema } from "../shared.js";
 import { authorSchema, codeLocationSchema } from "../shared.js";
 export type PatchState =
   | { status: "draft" }
   | { status: "open"; conflicts?: [string, string][] }
   | { status: "archived" }
   | { status: "merged"; revision: string; commit: string };
 export type PatchState = z.infer<typeof patchStateSchema>;
 const patchStateSchema = union([
   object({

     revision: string(),
     commit: string(),
   }),
 ]) satisfies ZodSchema<PatchState>;
 ]);
 export interface Merge {
   author: { id: string; alias?: string };
   revision: string;
   commit: string;
   timestamp: number;
 }
 export type Merge = z.infer<typeof mergeSchema>;
 const mergeSchema = object({
   author: object({ id: string(), alias: string().optional() }),
   author: authorSchema,
   revision: string(),
   commit: string(),
   timestamp: number(),
 }) satisfies ZodSchema<Merge>;
 });
 export type Verdict = "accept" | "reject";
 const reviewSchema = object({
   author: object({ id: string(), alias: string().optional() }),
   author: authorSchema,
   verdict: optional(union([literal("accept"), literal("reject")]).nullable()),
   comments: array(commentSchema),
   summary: string().nullable(),

     object({
       emoji: string(),
       location: codeLocationSchema.nullable(),
       authors: array(string()),
       authors: array(authorSchema),
     }),
   ),
   base: string(),

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

     | ((body: string, embeds: Embed[]) => Promise<void>)
     | undefined = undefined;
   export let reactOnComment:
     | ((nids: string[], reaction: string) => Promise<void>)
     | ((
         authors: Comment["reactions"][0]["authors"],
         reaction: string,
       ) => Promise<void>)
     | undefined = undefined;
 </script>

   export let reactions: Comment["reactions"] | undefined = undefined;
   const dispatch = createEventDispatcher<{
     select: { emoji: string; authors: string[] };
     select: Comment["reactions"][0];
   }>();
 </script>

     | ((commentId: string, comment: string, embeds: Embed[]) => Promise<void>)
     | undefined;
   export let reactOnComment:
     | ((commentId: string, nids: string[], reaction: string) => Promise<void>)
     | ((
         commentId: string,
         authors: Comment["reactions"][0]["authors"],
         reaction: string,
       ) => Promise<void>)
     | undefined;
   async function toggleReply() {

 <script lang="ts" strictEvents>
   import type { Reaction } from "@httpd-client/lib/project/comment";
   import { createEventDispatcher } from "svelte";
   import { formatNodeId, parseNodeId } from "@app/lib/utils";

   import IconSmall from "@app/components/IconSmall.svelte";
   import TextInput from "@app/components/TextInput.svelte";
   const dispatch = createEventDispatcher<{ save: string[] }>();
   const dispatch = createEventDispatcher<{
     save: Reaction["authors"];
   }>();
   export let locallyAuthenticated: boolean = false;
   export let assignees: string[] = [];
   export let assignees: Reaction["authors"] = [];
   export let submitInProgress: boolean = false;
   let showInput: boolean = false;
   let updatedAssignees: string[] = assignees;
   let updatedAssignees: Reaction["authors"] = assignees;
   let inputValue = "";
   let validationMessage: string | undefined = undefined;
   let valid: boolean = false;

       const parsedNodeId = parseNodeId(inputValue);
       if (parsedNodeId) {
         assignee = `${parsedNodeId.prefix}${parsedNodeId.pubkey}`;
         if (updatedAssignees.includes(assignee)) {
         if (Boolean(updatedAssignees.find(({ id }) => id === assignee))) {
           valid = false;
           validationMessage = "This assignee is already added";
         } else {

   function addAssignee() {
     if (valid && assignee) {
       updatedAssignees = [...updatedAssignees, assignee];
       updatedAssignees = [...updatedAssignees, { id: assignee }];
       inputValue = "";
       dispatch("save", updatedAssignees);
       showInput = false;

   }
   function removeAssignee(assignee: string) {
     updatedAssignees = updatedAssignees.filter(x => x !== assignee);
     updatedAssignees = updatedAssignees.filter(({ id }) => id !== assignee);
     dispatch("save", updatedAssignees);
     showInput = false;
   }

           variant="neutral"
           size="small"
           style="cursor: pointer;"
           on:click={() => (removeToggles[assignee] = !removeToggles[assignee])}>
           on:click={() =>
             (removeToggles[assignee.id] = !removeToggles[assignee.id])}>
           <div class="assignee">
             <Avatar inline nodeId={assignee} />
             <span>{formatNodeId(assignee)}</span>
             {#if removeToggles[assignee]}
             <Avatar inline nodeId={assignee.id} />
             <span>{formatNodeId(assignee.id)}</span>
             {#if removeToggles[assignee.id]}
               <IconButton title="remove assignee">
                 <IconSmall
                   name="cross"
                   on:click={() => removeAssignee(assignee)} />
                   on:click={() => removeAssignee(assignee.id)} />
               </IconButton>
             {/if}
           </div>

 <script lang="ts">
   import type { Reaction } from "@httpd-client/lib/project/comment";
   import type {
     BaseUrl,
     Comment,
     Embed,
     Issue,
     IssueState,
     Embed,
     Project,
   } from "@httpd-client";
   import type { Session } from "@app/lib/httpd";

   async function reactOnComment(
     session: Session,
     commentId: string,
     nids: string[],
     authors: Comment["reactions"][0]["authors"],
     reaction: string,
   ) {
     console.log(session.publicKey, authors);
     try {
       await api.project.updateIssue(
         project.id,

           type: "comment.react",
           id: commentId,
           reaction,
           active: nids.includes(session.publicKey) ? false : true,
           active: !Boolean(
             authors.find(
               ({ id }) => utils.parseNodeId(id)?.pubkey === session.publicKey,
             ),
           ),
         },
         session.id,
       );

     }
   }
   async function saveAssignees(sessionId: string, assignees: string[]) {
   async function saveAssignees(
     sessionId: string,
     assignees: Reaction["authors"],
   ) {
     try {
       await api.project.updateIssue(
         project.id,
         issue.id,
         { type: "assign", assignees },
         { type: "assign", assignees: assignees.map(({ id }) => id) },
         sessionId,
       );
     } catch (error) {

           revision: revisionId,
           comment: commentId,
           reaction,
           active: authors.includes(session.publicKey) ? false : true,
           active: Boolean(authors.find(({ id }) => id === session.publicKey)),
         },
         session.id,
       );

   async function reactOnRevision(
     session: Session,
     revisionId: string,
     authors: string[],
     authors: Revision["reactions"][0]["authors"],
     reaction: string,
   ) {
     try {

   import File from "./Tree/File.svelte";
   import Folder from "./Tree/Folder.svelte";
   import Link from "@app/components/Link.svelte";
   import Submodule from "./Tree/Submodule.svelte";
   export let baseUrl: BaseUrl;
   export let fetchTree: (path: string) => Promise<Tree | undefined>;

       {peer}
       {projectId}
       {revision} />
   {:else if entry.kind === "submodule"}
     <Submodule name={entry.name} oid={entry.oid} />
   {:else}
     <Link
       route={{

 <script lang="ts">
   import IconSmall from "@app/components/IconSmall.svelte";
   import { formatCommit } from "@app/lib/utils";
   export let name: string;
   export let oid: string;
 </script>
 <style>
   .file {
     border-radius: var(--border-radius-tiny);
     display: flex;
     line-height: 1.5em;
     margin: 0.25rem 0;
     padding: 0.25rem 0.875rem;
     width: 100%;
   }
   .name {
     margin-left: 0.25rem;
     user-select: none;
     white-space: nowrap;
     text-overflow: ellipsis !important;
     color: var(--color-foreground-dim);
     overflow: hidden;
     font-size: var(--font-size-small);
     font-weight: var(--font-weight-medium);
   }
   .icon-container {
     color: var(--color-fill-secondary);
     display: flex;
     justify-content: center;
     align-items: center;
     margin-right: 0.125rem;
   }
 </style>
 <div class="file">
   <div class="icon-container">
     <IconSmall name="link" />
   </div>
   <span class="name">{name} @ {formatCommit(oid)}</span>
 </div>

   }
 });
 test("submodules", async ({ page }) => {
   await page.goto(sourceBrowsingUrl);
   await expect(page.getByText("rips @ 329dee9")).toBeVisible();
 });
 test("files with special characters in the filename", async ({ page }) => {
   await page.goto(sourceBrowsingUrl);

   await page.goto(sourceBrowsingUrl);
   await page.getByTitle("Change peer").click();
   await page.getByRole("link", { name: "bob" }).click();
   await page.getByRole("link", { name: "Commits 7" }).click();
   await page.getByRole("link", { name: "Commits 8" }).click();
   await page.getByText("Update readme").click();
   await expect(page).toHaveURL(commitUrl);

     };
   });
   await page.goto(commitUrl);
   await expect(page.getByText("Bob Belcher committed 28f3710")).toBeVisible();
   await expect(
     page.getByText(`Bob Belcher committed ${shortBobHead}`),
   ).toBeVisible();
 });
 test("modified file", async ({ page }) => {

   aliceMainHead,
   expect,
   gitOptions,
   shortBobHead,
   sourceBrowsingUrl,
   test,
 } from "@tests/support/fixtures.js";

 test("peer and branch switching", async ({ page }) => {
   await page.goto(sourceBrowsingUrl);
   await page.getByRole("link", { name: "Commits 6" }).click();
   await page.getByRole("link", { name: "Commits 7" }).click();
   // Alice's peer.
   {

     await expect(page.getByTitle("Change peer")).toHaveText("alice Delegate");
     await expect(page.getByText("Thursday, November 17, 2022")).toBeVisible();
     await expect(page.locator(".list .teaser")).toHaveCount(6);
     await expect(page.locator(".list .teaser")).toHaveCount(7);
     const latestCommit = page.locator(".teaser").first();
     await expect(latestCommit).toContainText("Add README.md");
     await expect(latestCommit).toContainText("Add submodule");
     await expect(latestCommit).toContainText(aliceMainHead.substring(0, 7));
     const earliestCommit = page.locator(".teaser").last();

     await expect(page.getByText("Thursday, November 17, 2022")).toBeVisible();
     await expect(page.locator(".list").last().locator(".teaser")).toHaveCount(
 ,
 ,
     );
     const latestCommit = page.locator(".teaser").first();
     await expect(latestCommit).toContainText("Update readme");
     await expect(latestCommit).toContainText("28f3710");
     await expect(latestCommit).toContainText(shortBobHead);
     const earliestCommit = page.locator(".teaser").last();
     await expect(earliestCommit).toContainText(

 import { createPeerManager } from "@tests/support/peerManager.js";
 import { createProject } from "@tests/support/project.js";
 import type { PeerManager, RadiclePeer } from "./peerManager.js";
 import { formatCommit } from "@app/lib/utils.js";
 export { expect };

     const { stdout } = await peer.spawn("rad-web", [
       "http://localhost:3001",
       "--no-open",
       "--path",
       "/",
       "--connect",
       `${peer.httpdBaseUrl.hostname}:${peer.httpdBaseUrl.port}`,
     ]);