| 1 | /** |
| 2 | * Which frame a page is drawn in. |
| 3 | * |
| 4 | * - `standalone`: signing in, signing up and choosing a workspace. The |
| 5 | * page alone, centred, with the logo and a quiet row of links at the |
| 6 | * foot: no header, no sidebar, no rail. |
| 7 | * - `app`: someone signed in, everywhere else. The rail, the mode's |
| 8 | * sidebar and the page in its panel, always about their current |
| 9 | * workspace, even on public pages such as Explore, a profile or another |
| 10 | * workspace's public project. |
| 11 | * - `public`: a visitor who is not signed in (or has not confirmed their |
| 12 | * address yet), on every other page: a plain header with the logo, |
| 13 | * Explore, Docs and signing in, the page at full width, and the footer. |
| 14 | */ |
| 15 | |
| 16 | import type { Abilities, Capability } from "@g1t/contracts"; |
| 17 | |
| 18 | export type Frame = "standalone" | "public" | "app"; |
| 19 | |
| 20 | /** Pages that are drawn on their own, whoever opens them. */ |
| 21 | const STANDALONE = new Set([ |
| 22 | "/login", |
| 23 | "/login/two-factor", |
| 24 | "/register", |
| 25 | "/logout", |
| 26 | "/verify", |
| 27 | "/confirm-email", |
| 28 | "/forgot", |
| 29 | "/reset", |
| 30 | "/device", |
| 31 | "/oauth/authorize", |
| 32 | "/workspaces/new", |
| 33 | "/integrations/github/setup", |
| 34 | ]); |
| 35 | |
| 36 | /** Marketing pages: the public header and footer, even for someone signed in. */ |
| 37 | const MARKETING = new Set(["/download"]); |
| 38 | |
| 39 | /** The page's path without a trailing slash or a click's `.data`. */ |
| 40 | function framePath(pathname: string): string { |
| 41 | const path = pathname.replace(/\.data$/, ""); |
| 42 | return path.length > 1 ? path.replace(/\/+$/, "") : path; |
| 43 | } |
| 44 | |
| 45 | /** |
| 46 | * The frame for `pathname`. `viewer` says whether someone is signed in and |
| 47 | * confirmed (`signedIn`), and whether they belong to a workspace yet: until |
| 48 | * they do, answering an invitation is part of getting started too. |
| 49 | */ |
| 50 | export function frameOf(pathname: string, viewer: { signedIn: boolean; workspace: boolean }): Frame { |
| 51 | const path = framePath(pathname); |
| 52 | if (STANDALONE.has(path)) return "standalone"; |
| 53 | // Marketing pages are the site's front, whoever reads them: never inside the app's rail and sidebar. |
| 54 | if (MARKETING.has(path)) return "public"; |
| 55 | // An invite link, and signing in with GitHub, are the front door. |
| 56 | if (path.startsWith("/invite/") || path === "/auth/github" || path.startsWith("/auth/github/")) return "standalone"; |
| 57 | if (path === "/invitations" && viewer.signedIn && !viewer.workspace) return "standalone"; |
| 58 | return viewer.signedIn ? "app" : "public"; |
| 59 | } |
| 60 | |
| 61 | /** The project pages the sidebar lists, by key, for a member or not. */ |
| 62 | export type ProjectPage = |
| 63 | | "code" |
| 64 | | "issues" |
| 65 | | "pulls" |
| 66 | | "actions" |
| 67 | | "deployments" |
| 68 | | "observability" |
| 69 | | "security" |
| 70 | | "insights" |
| 71 | | "secrets" |
| 72 | | "environments" |
| 73 | | "domains" |
| 74 | | "runners" |
| 75 | | "webhooks" |
| 76 | | "storage" |
| 77 | | "daemons" |
| 78 | | "settings"; |
| 79 | |
| 80 | /** |
| 81 | * What a page needs beyond a role on the repository, once what the viewer |
| 82 | * may do is known: Security's findings are for people who can push. |
| 83 | */ |
| 84 | export const PROJECT_OPERATIONS = ["secrets", "environments", "domains", "runners", "webhooks"] as const; |
| 85 | |
| 86 | export const PAGE_NEEDS: Partial<Record<ProjectPage, Capability>> = { |
| 87 | security: "push", |
| 88 | secrets: "manage_integrations", environments: "manage_integrations", domains: "manage_integrations", |
| 89 | runners: "manage_integrations", webhooks: "manage_integrations", |
| 90 | }; |
| 91 | |
| 92 | /** |
| 93 | * A project's menu, in order. Security and Settings are for people with a |
| 94 | * role on its repository, and a page in `PAGE_NEEDS` only for those whose |
| 95 | * role has its capability (`can`, once the repository's page has loaded); |
| 96 | * everyone who can see the project sees the rest. |
| 97 | */ |
| 98 | export function projectPages(member: boolean, can?: Partial<Abilities>): ProjectPage[] { |
| 99 | const pages: (ProjectPage | false)[] = [ |
| 100 | "code", |
| 101 | "issues", |
| 102 | "pulls", |
| 103 | "actions", |
| 104 | // A public repository's deployments and build logs are for anyone, as its code is. |
| 105 | "deployments", |
| 106 | // Logs and requests are not: they can hold what only the people running it should read. |
| 107 | member && "observability", |
| 108 | member && "security", |
| 109 | "insights", |
| 110 | ...PROJECT_OPERATIONS.map((page) => member && page), |
| 111 | member && "storage", |
| 112 | member && "daemons", |
| 113 | member && "settings", |
| 114 | ]; |
| 115 | return pages.filter( |
| 116 | (page): page is ProjectPage => |
| 117 | page !== false && (!can || !PAGE_NEEDS[page] || Boolean(can[PAGE_NEEDS[page]!])), |
| 118 | ); |
| 119 | } |
| 120 | |
| 121 | /** |
| 122 | * A project's pages as the phone's strip of tabs under its name names them |
| 123 | * (routes/repo/layout.tsx): the sidebar's words, and the paths under the |
| 124 | * project at which each is the current one. |
| 125 | */ |
| 126 | export const PROJECT_PAGE_LINKS: Record<ProjectPage, { label: string; path: string; also: string[]; soon?: boolean }> = { |
| 127 | code: { label: "Code", path: "code", also: ["tree", "blob", "commits", "commit", "branches", "tags", "releases", "compare"] }, |
| 128 | issues: { label: "Issues", path: "issues", also: ["milestones", "labels"] }, |
| 129 | pulls: { label: "Pull requests", path: "pulls", also: ["pull", "work", "queue", "sessions"] }, |
| 130 | actions: { label: "Workflows", path: "actions", also: [] }, |
| 131 | deployments: { label: "Deployments", path: "deployments", also: ["settings/deployments"] }, |
| 132 | observability: { label: "Observability", path: "observability", also: [] }, |
| 133 | security: { label: "Security", path: "security", also: [] }, |
| 134 | insights: { label: "Insights", path: "contributors", also: ["activity", "stargazers"] }, |
| 135 | secrets: { label: "Environment variables", path: "settings/secrets", also: [] }, |
| 136 | environments: { label: "Environments", path: "settings/environments", also: [] }, |
| 137 | domains: { label: "Domains", path: "settings/domains", also: [] }, |
| 138 | runners: { label: "Runners", path: "settings/runners", also: [] }, |
| 139 | webhooks: { label: "Webhooks", path: "settings/webhooks", also: [] }, |
| 140 | storage: { label: "Storage", path: "soon/storage", also: [], soon: true }, |
| 141 | daemons: { label: "Daemons", path: "soon/daemons", also: [], soon: true }, |
| 142 | settings: { label: "Settings", path: "settings", also: [] }, |
| 143 | }; |
| 144 | |
| 145 | /** |
| 146 | * Which of a project's pages `rest` (the path under the project, no |
| 147 | * leading slash) is on: "overview" for the project itself. `soon` says |
| 148 | * which page a roadmap page (`soon/<key>`) sits under. |
| 149 | */ |
| 150 | export function projectPageAt(rest: string, soon: Record<string, ProjectPage> = {}): ProjectPage | "overview" | null { |
| 151 | const path = rest.replace(/^\/+|\/+$/g, ""); |
| 152 | if (path === "") return "overview"; |
| 153 | const soonKey = /^soon\/([^/]+)/.exec(path)?.[1]; |
| 154 | if (soonKey && soon[soonKey]) return soon[soonKey]!; |
| 155 | for (const [page, link] of Object.entries(PROJECT_PAGE_LINKS) as [ProjectPage, (typeof PROJECT_PAGE_LINKS)[ProjectPage]][]) { |
| 156 | if ([link.path, ...link.also].some((prefix) => path === prefix || path.startsWith(`${prefix}/`))) return page; |
| 157 | } |
| 158 | return null; |
| 159 | } |