await navigate("replace", newRoute);

}

function pathToRoute(path: string): Route | null {

  // This matches e.g. an empty string

  if (!path) {

  }

}

  return `${baseUrl.scheme}://${baseUrl.hostname}:${baseUrl.port}/raw/${id}/${commit}`;

}

export function formatLocationHash(hash: string | null): number | null {

  if (hash && hash.match(/^#L[0-9]+$/)) return parseInt(hash.slice(2));

  return null;

  return new Date(timestamp).toUTCString();

};

// Check whether the input is a URL.

export function isUrl(input: string): boolean {

  return /^https?:\/\//.test(input);

<script lang="ts" strictEvents>

  import * as utils from "@app/lib/utils";

  import Dropdown from "@app/components/Dropdown.svelte";

  import DropdownItem from "@app/components/Dropdown/DropdownItem.svelte";

  export let branches: Record<string, string>;

  export let projectDefaultBranch: string;

  let branchLabel: string | null = null;

    .sort()

    .map(b => ({ key: b, value: b, title: `Switch to ${b}`, badge: null }));

  $: showSelector = branchList.length > 1;

    branchLabel = revision;

  } else {

    branchLabel = null;

  }

      {utils.formatCommit(commit)}

    </div>

    <!-- If there is no branch listing available, show default branch name if commit is head and else show entire commit -->

    <div class="stat branch not-allowed">

      {projectDefaultBranch}

    </div>

  import * as utils from "@app/lib/utils";

  import { HttpdClient } from "@httpd-client";

  import Button from "@app/components/Button.svelte";

  import Loading from "@app/components/Loading.svelte";

  export let project: Project;

  export let baseUrl: BaseUrl;

  export let tree: Tree;

  export let activeRoute: ProjectRoute;

  $: path = activeRoute.params.path || "/";

  $: line = activeRoute.params.line;

  // When the component is loaded the first time, the blob is yet to be loaded.

  let state: State = { status: Status.Loading, path };

            {path}

            {fetchTree}

            {loadingPath}

            on:select={() => {

              // Close mobile tree if user navigates to other file

              mobileFileTree = false;

  export let project: Project;

  export let activeRoute: ProjectRoute;

  export let peers: Remote[];

  export let branches: Record<string, string>;

  {/if}

  <BranchSelector

    {branches}

    {revision}

  <ProjectLink

    projectParams={{

      view: {

        resource: "history",

      },

      search: undefined,

    }}>

    <SquareButton

  export let fetchTree: (path: string) => Promise<Tree | undefined>;

  export let path: string;

  export let tree: Tree;

  export let loadingPath: string | null = null;

  const dispatch = createEventDispatcher<{ select: string }>();

    <Folder

      {fetchTree}

      {loadingPath}

      name={entry.name}

      prefix={`${entry.path}/`}

      currentPath={path}

      on:select={onSelect} />

  {:else}

    <ProjectLink

      on:click={() => onSelect({ detail: entry.path })}>

      <File

        active={entry.path === path}

  export let prefix: string;

  export let currentPath: string;

  export let loadingPath: string | null = null;

  let expanded = currentPath.indexOf(prefix) === 0;

  let tree: Promise<Tree | undefined> = fetchTree(prefix).then(tree => {

              on:select={onSelectFile}

              prefix={`${entry.path}/`}

              {loadingPath}

              {currentPath} />

          {:else}

            <ProjectLink

              projectParams={{

                view: { resource: "tree" },

                path: entry.path,

              }}

              on:click={() => onSelectFile({ detail: entry.path })}>

              <File

  $: id = activeRoute.params.id;

  $: peer = activeRoute.params.peer;

  $: searchParams = new URLSearchParams(activeRoute.params.search || "");

  $: issueFilter = (searchParams.get("state") as IssueStatus) || "open";

    input: string,

    branches: Record<string, string>,

  ): { path?: string; revision?: string } {

    const branch = Object.entries(branches).find(([branchName]) =>

      input.startsWith(branchName),

    );

    if (branch) {

      const [rev, path] = [

        input.slice(0, branch[0].length),

        input.slice(branch[0].length + 1),

      ];

      parsed.revision = rev;

      parsed.revision = commitPath[0];

    } else {

      parsed.path = input;

    }

        { replace: true },

      );

    }

    return { project, branches, peers };

  };

  async function getRoot(

    branches: Record<string, string>,

    const tree = await api.project.getTree(id, commit);

  }

  function handleIssueCreation({ detail: issueId }: CustomEvent<string>) {

  // React to peer changes

  $: projectPromise = getProject(id, peer);

</script>

<style>

    </header>

  </main>

{:then { project, peers, branches }}

  <main>

    <ProjectMeta {project} nodeId={peer} />

      <Loading center />

      <Header

        projectId={project.id}

        projectName={project.name}

        <SourceBrowsingHeader

          {project}

          {activeRoute}

          {peers}

          {branches}

          commitCount={tree.stats.commits}

      {/if}

      {#if activeRoute.params.view.resource === "tree"}

      {:else if activeRoute.params.view.resource === "history"}

        <History projectId={project.id} {baseUrl} parentCommit={commit} />

      {:else if activeRoute.params.view.resource === "commits"}

    await expect(page).toHaveURL(projectTreeURL);

    await page.locator('role=link[name="8 commits"]').click();

    await expectBackAndForwardNavigationWorks(projectTreeURL, page);

    await expectUrlPersistsReload(page);

  const { rid, projectFolder } = await alice.createProject("alice-project");

  await page.goto(`/seeds/127.0.0.1:8090/${rid}`);

  await page.locator('role=link[name="1 commit"]').click();

  await page.reload();

  await expect(page.getByTitle("Current branch")).toContainText("main 516fa74");

});

  // eslint-disable-next-line no-empty-pattern

  stateDir: async ({}, use, testInfo) => {

    await Fs.rm(stateDir, { recursive: true, force: true });

    await Fs.mkdir(stateDir, { recursive: true });

    await use(stateDir);

    if (

      (testInfo.status === "passed" || testInfo.status === "skipped")

    ) {

      await Fs.rm(stateDir, { recursive: true });

    }

  },

});

    name: "alice",

    gitOptions: gitOptions["alice"],

  });

  const bob = await peerManager.startPeer({

    name: "bob",

    gitOptions: gitOptions["bob"],

  });

  await palm.startNode({ trackingPolicy: "track", trackingScope: "all" });

  await alice.startNode();

  await bob.startNode();

  await bob.connect(palm);

  await alice.git(["clone", sourceBrowsingDir], { cwd: alice.checkoutPath });

  // Needed due to rad init not pushing all branches.

  await alice.waitForRoutes(rid, alice.nodeId, palm.nodeId);

  await bob.waitForRoutes(rid, alice.nodeId, palm.nodeId);

    Path.join(bob.checkoutPath, "source-browsing", "README.md"),

    "Updated readme",

  );

}

export const aliceMainHead = "fcc929424b82984b7cbff9c01d2e20d9b1249842";

import type { ExecaChildProcess, Options } from "execa";

import * as Fs from "node:fs/promises";

import * as Path from "node:path";

import * as Stream from "node:stream";

import getPort from "get-port";

import { execa } from "execa";

import * as Process from "./process.js";

import { sleep } from "@app/lib/sleep.js";

export type RefsUpdate =

  public nodeId: string;

  #seed: string;

  #radHome: string;

  #eventRecords: NodeEvent[] = [];

  #outputLog: Stream.Writable;

  #gitOptions?: Record<string, string>;

    checkoutPath: string;

    nodeId: string;

    seed: string;

    gitOptions?: Record<string, string>;

    radHome: string;

    logFile: Stream.Writable;

    this.nodeId = props.nodeId;

    this.#gitOptions = props.gitOptions;

    this.#seed = props.seed;

    this.#radHome = props.radHome;

    this.#outputLog = props.logFile;

  }

    const radHome = Path.join(dataPath, name, "home");

    await Fs.mkdir(radHome, { recursive: true });

    const env = {

      ...gitOptions,

      RAD_HOME: radHome,

      RAD_PASSPHRASE: "asdf",

      RAD_SEED: seed,

    };

    await execa("rad", ["auth"], { env });

      checkoutPath,

      gitOptions,

      seed,

      nodeId,

      radHome,

      logFile,

    this.spawn("radicle-httpd", ["--listen", `0.0.0.0:${port}`]);

    await waitOn({

      timeout: 7000,

    });

  }

    }

    // eslint-disable-next-line @typescript-eslint/no-floating-promises

    await waitOn({

    });

    this.rad(["node", "events"], { cwd: this.#radHome }).stdout?.on(

    let remaining = nodes;

    while (remaining.length > 0) {

      entries.split("\n").forEach(entry => {

        if (entry && entry.trim() !== "") {

    return `/seeds/127.0.0.1:8080/${rid}`;

  }

  public git(args: string[] = [], opts?: Options): ExecaChildProcess {

    return this.spawn("git", args, { ...opts });

  }

    opts?: Options,

  ): ExecaChildProcess {

    opts = {

      ...opts,

      env: {

        ...opts?.env,

        RAD_PASSPHRASE: "asdf",

        RAD_COMMIT_TIME: "1671125284",

        RAD_SEED: this.#seed,

      },

    };

    const childProcess = Process.spawn(cmd, args, opts);

import { describe, expect, test } from "vitest";

import { testExports } from "@app/lib/router";

// Defining the window.origin value, since vitest doesn't provide one.

window.origin = "http://localhost:3000";

describe("routeToPath", () => {

  test.each([

    { input: { resource: "home" }, output: "/", description: "Home Route" },

      description: "Seed Project Route",

    },

  ])("$description", (route: any) => {

  });

});

  });

  test.each([

    { url: "https://app.radicle.xyz", expected: true },

    { url: "http://app.radicle.xyz", expected: true },

    { url: "http://app", expected: true },