tenseleyflow/shithub / 392e063

+GET  /orgs/{org}/repositories      repository list with filters + pagination

+`GET /orgs/{org}/repositories` is the dedicated organization

+repositories surface, matching GitHub's current org route shape. It

+uses the same policy-filtered visible repo set as the overview, then

+applies query, type, language, sort, and page parameters in the handler.

+The page renders 30 repositories per page with bordered GitHub-style

+rows, topics, language/license/star/fork metadata, default-branch

+activity sparklines, and numbered pagination.

+	// OrgRepositoriesMounter registers /orgs/{org}/repositories. The

+	// GitHub-style /orgs prefix avoids stealing /{user}/repositories

+	// from a real user-owned repo named "repositories".

+	OrgRepositoriesMounter func(chi.Router)

+		if deps.OrgRepositoriesMounter != nil {

+			deps.OrgRepositoriesMounter(r)

+		}

+//	GET  /orgs/{org}/repositories                          repository list

+		"Title":              org.DisplayName,

+		"OGTitle":            org.DisplayName,

+		"OGDescription":      org.Description,

+		"OGImage":            avatarURL,

+		"Org":                org,

+		"AvatarURL":          avatarURL,

+		"ActiveOrgNav":       "overview",

+		"WebsiteSafe":        safeWebsite(org.Website),

+		"Repos":              repoRows,

+		"HasMoreRepos":       len(repos) > orgHomepageRepoLimit,

+		"OrgRepositoriesURL": orgRepositoriesBaseURL(string(org.Slug)),

+		"PinnedRepos":        pinnedRepos,

+		"PinCandidates":      pinCandidates,

+		"PinsRemaining":      profilePinsRemaining(pinCandidates),

+		"RepoCount":          int64(len(repos)),

+		"TeamCount":          teamCount,

+		"MemberCount":        memberCount,

+		"People":             limitOrgPeople(people, orgHomepagePeopleLimit),

+		"TopLanguages":       orgTopLanguages(repos),

+		"TopTopics":          orgTopTopics(repos),

+		"ViewAs":             viewAs,

+		"IsOwner":            isOwner,

+		"IsMember":           isMember,

+		"CanCustomizePins":   isOwner,

+		"PinsAction":         "/" + url.PathEscape(org.Slug) + "/pins",

+		"CanCreateRepo":      isOwner || (isMember && org.AllowMemberRepoCreate),

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+package profile

+

+import (

+	"context"

+	"net/http"

+	"net/url"

+	"sort"

+	"strconv"

+	"strings"

+

+	"github.com/go-chi/chi/v5"

+

+	"github.com/tenseleyFlow/shithub/internal/orgs"

+	orgsdb "github.com/tenseleyFlow/shithub/internal/orgs/sqlc"

+	"github.com/tenseleyFlow/shithub/internal/web/middleware"

+)

+

+const orgRepositoriesPerPage = 30

+

+type orgRepositoryFilterOption struct {

+	Label    string

+	Value    string

+	Href     string

+	Selected bool

+	Count    int

+}

+

+type orgRepositoryPageLink struct {

+	Number  int

+	Href    string

+	Current bool

+}

+

+// MountOrgRepositories registers the GitHub-style organization

+// repositories route. It deliberately uses /orgs/{org}/repositories

+// instead of /{org}/repositories so ordinary repos named "repositories"

+// remain reachable at /{owner}/repositories.

+func (h *Handlers) MountOrgRepositories(r chi.Router) {

+	r.Get("/orgs/{org}/repositories", h.serveOrgRepositories)

+}

+

+func (h *Handlers) serveOrgRepositories(w http.ResponseWriter, r *http.Request) {

+	ctx := r.Context()

+	org, err := orgsdb.New().GetOrgBySlug(ctx, h.d.Pool, chi.URLParam(r, "org"))

+	if err != nil {

+		h.d.Render.HTTPError(w, r, http.StatusNotFound, r.URL.Path)

+		return

+	}

+	if org.DeletedAt.Valid {

+		h.renderUnavailable(w, r, string(org.Slug))

+		return

+	}

+

+	viewer := middleware.CurrentUserFromContext(ctx)

+	isOwner, isMember, viewAs := h.orgViewerState(ctx, org.ID, viewer)

+	repos := h.orgProfileRepos(ctx, org.ID, viewer)

+

+	query := strings.TrimSpace(r.URL.Query().Get("q"))

+	typeFilter := normalizeOrgRepositoryType(r.URL.Query().Get("type"))

+	languageFilter := strings.TrimSpace(r.URL.Query().Get("language"))

+	sortKey := normalizeOrgRepositorySort(r.URL.Query().Get("sort"))

+

+	filtered := filterOrgRepositories(repos, query, typeFilter, languageFilter)

+	sortOrgRepositories(filtered, sortKey)

+	page := parseOrgRepositoryPage(r.URL.Query().Get("page"))

+	pageRepos, currentPage, pageCount := paginateOrgRepositories(filtered, page)

+	pageRepos = h.withOrgRepoActivity(ctx, string(org.Slug), pageRepos)

+

+	people := h.orgProfilePeople(ctx, orgsdb.New(), org.ID)

+	teamCount := int64(0)

+	if isMember || viewer.IsSiteAdmin {

+		_ = h.d.Pool.QueryRow(ctx, `SELECT count(*) FROM teams WHERE org_id = $1`, org.ID).Scan(&teamCount)

+	}

+

+	baseURL := orgRepositoriesBaseURL(string(org.Slug))

+	typeFilters := orgRepositoryTypeFilters(baseURL, repos, query, typeFilter, languageFilter, sortKey)

+	languageFilters := orgRepositoryLanguageFilters(baseURL, repos, query, typeFilter, languageFilter, sortKey)

+	sortOptions := orgRepositorySortOptions(baseURL, query, typeFilter, languageFilter, sortKey)

+	avatarURL := "/avatars/" + url.PathEscape(string(org.Slug))

+	titleName := org.DisplayName

+	if titleName == "" {

+		titleName = string(org.Slug)

+	}

+	data := map[string]any{

+		"Title":                 titleName + " · repositories",

+		"OGTitle":               titleName + " repositories",

+		"OGDescription":         org.Description,

+		"OGImage":               avatarURL,

+		"Org":                   org,

+		"AvatarURL":             avatarURL,

+		"ActiveOrgNav":          "repositories",

+		"Repos":                 pageRepos,

+		"RepoCount":             int64(len(repos)),

+		"FilteredCount":         len(filtered),

+		"HasActiveFilters":      query != "" || typeFilter != "all" || languageFilter != "" || sortKey != "updated",

+		"Query":                 query,

+		"SelectedType":          typeFilter,

+		"SelectedTypeLabel":     selectedOrgRepositoryOptionLabel(typeFilters, "All"),

+		"SelectedLanguage":      languageFilter,

+		"SelectedLanguageLabel": selectedOrgRepositoryOptionLabel(languageFilters, "All languages"),

+		"SelectedSort":          sortKey,

+		"SelectedSortLabel":     selectedOrgRepositoryOptionLabel(sortOptions, "Last updated"),

+		"TypeFilters":           typeFilters,

+		"LanguageFilters":       languageFilters,

+		"SortOptions":           sortOptions,

+		"Page":                  currentPage,

+		"PageCount":             pageCount,

+		"PaginationPages":       orgRepositoryPaginationPages(baseURL, query, typeFilter, languageFilter, sortKey, currentPage, pageCount),

+		"HasPrev":               currentPage > 1 && pageCount > 0,

+		"HasNext":               currentPage < pageCount,

+		"PrevHref":              orgRepositoryURL(baseURL, query, typeFilter, languageFilter, sortKey, currentPage-1),

+		"NextHref":              orgRepositoryURL(baseURL, query, typeFilter, languageFilter, sortKey, currentPage+1),

+		"MemberCount":           int64(len(people)),

+		"TeamCount":             teamCount,

+		"ViewAs":                viewAs,

+		"IsOwner":               isOwner,

+		"IsMember":              isMember,

+		"CanCreateRepo":         isOwner || (isMember && org.AllowMemberRepoCreate),

+	}

+	if !viewer.IsAnonymous() {

+		w.Header().Set("Cache-Control", "no-cache, private")

+	} else {

+		w.Header().Set("Cache-Control", "max-age=120")

+	}

+	if err := h.d.Render.RenderPage(w, r, "orgs/repositories", data); err != nil {

+		h.d.Logger.ErrorContext(ctx, "orgs repositories: render", "error", err)

+	}

+}

+

+func (h *Handlers) orgViewerState(ctx context.Context, orgID int64, viewer middleware.CurrentUser) (bool, bool, string) {

+	isOwner := false

+	isMember := false

+	if !viewer.IsAnonymous() {

+		deps := orgs.Deps{Pool: h.d.Pool, Logger: h.d.Logger}

+		isOwner, _ = orgs.IsOwner(ctx, deps, orgID, viewer.ID)

+		isMember, _ = orgs.IsMember(ctx, deps, orgID, viewer.ID)

+	}

+	viewAs := "Public"

+	switch {

+	case !viewer.IsAnonymous() && viewer.IsSiteAdmin:

+		viewAs = "Site admin"

+	case isOwner:

+		viewAs = "Owner"

+	case isMember:

+		viewAs = "Member"

+	}

+	return isOwner, isMember, viewAs

+}

+

+func filterOrgRepositories(repos []orgProfileRepo, query, typeFilter, languageFilter string) []orgProfileRepo {

+	query = strings.ToLower(strings.TrimSpace(query))

+	languageFilter = strings.TrimSpace(languageFilter)

+	out := make([]orgProfileRepo, 0, len(repos))

+	for _, repo := range repos {

+		if !orgRepositoryMatchesType(repo, typeFilter) {

+			continue

+		}

+		if languageFilter != "" && !strings.EqualFold(repo.PrimaryLanguage, languageFilter) {

+			continue

+		}

+		if query != "" && !orgRepositoryMatchesQuery(repo, query) {

+			continue

+		}

+		out = append(out, repo)

+	}

+	return out

+}

+

+func orgRepositoryMatchesType(repo orgProfileRepo, typeFilter string) bool {

+	switch typeFilter {

+	case "public":

+		return repo.Visibility == "public"

+	case "private":

+		return repo.Visibility == "private"

+	case "source":

+		return !repo.IsFork && !repo.IsArchived

+	case "fork":

+		return repo.IsFork

+	case "archived":

+		return repo.IsArchived

+	default:

+		return true

+	}

+}

+

+func orgRepositoryMatchesQuery(repo orgProfileRepo, query string) bool {

+	if strings.Contains(strings.ToLower(repo.Name), query) ||

+		strings.Contains(strings.ToLower(repo.Description), query) ||

+		strings.Contains(strings.ToLower(repo.PrimaryLanguage), query) {

+		return true

+	}

+	for _, topic := range repo.Topics {

+		if strings.Contains(strings.ToLower(topic), query) {

+			return true

+		}

+	}

+	return false

+}

+

+func sortOrgRepositories(repos []orgProfileRepo, sortKey string) {

+	sort.SliceStable(repos, func(i, j int) bool {

+		switch sortKey {

+		case "name":

+			return strings.ToLower(repos[i].Name) < strings.ToLower(repos[j].Name)

+		case "stars":

+			if repos[i].StarCount != repos[j].StarCount {

+				return repos[i].StarCount > repos[j].StarCount

+			}

+		}

+		if !repos[i].UpdatedAt.Equal(repos[j].UpdatedAt) {

+			return repos[i].UpdatedAt.After(repos[j].UpdatedAt)

+		}

+		return strings.ToLower(repos[i].Name) < strings.ToLower(repos[j].Name)

+	})

+}

+

+func normalizeOrgRepositoryType(value string) string {

+	switch strings.ToLower(strings.TrimSpace(value)) {

+	case "public", "private", "fork", "archived":

+		return strings.ToLower(strings.TrimSpace(value))

+	case "source", "sources":

+		return "source"

+	case "forks":

+		return "fork"

+	default:

+		return "all"

+	}

+}

+

+func normalizeOrgRepositorySort(value string) string {

+	switch strings.ToLower(strings.TrimSpace(value)) {

+	case "name", "stars":

+		return strings.ToLower(strings.TrimSpace(value))

+	default:

+		return "updated"

+	}

+}

+

+func parseOrgRepositoryPage(value string) int {

+	page, err := strconv.Atoi(strings.TrimSpace(value))

+	if err != nil || page < 1 {

+		return 1

+	}

+	return page

+}

+

+func paginateOrgRepositories(repos []orgProfileRepo, page int) ([]orgProfileRepo, int, int) {

+	if len(repos) == 0 {

+		return nil, 1, 0

+	}

+	pageCount := (len(repos) + orgRepositoriesPerPage - 1) / orgRepositoriesPerPage

+	if page > pageCount {

+		page = pageCount

+	}

+	start := (page - 1) * orgRepositoriesPerPage

+	end := start + orgRepositoriesPerPage

+	if end > len(repos) {

+		end = len(repos)

+	}

+	return repos[start:end], page, pageCount

+}

+

+func orgRepositoriesBaseURL(orgSlug string) string {

+	return "/orgs/" + url.PathEscape(orgSlug) + "/repositories"

+}

+

+func orgRepositoryURL(baseURL, query, typeFilter, languageFilter, sortKey string, page int) string {

+	values := url.Values{}

+	if query != "" {

+		values.Set("q", query)

+	}

+	if typeFilter != "" && typeFilter != "all" {

+		values.Set("type", typeFilter)

+	}

+	if languageFilter != "" {

+		values.Set("language", languageFilter)

+	}

+	if sortKey != "" && sortKey != "updated" {

+		values.Set("sort", sortKey)

+	}

+	if page > 1 {

+		values.Set("page", strconv.Itoa(page))

+	}

+	if encoded := values.Encode(); encoded != "" {

+		return baseURL + "?" + encoded

+	}

+	return baseURL

+}

+

+func orgRepositoryTypeFilters(baseURL string, repos []orgProfileRepo, query, selected, language, sortKey string) []orgRepositoryFilterOption {

+	counts := map[string]int{"all": len(repos)}

+	for _, repo := range repos {

+		if repo.Visibility == "public" {

+			counts["public"]++

+		}

+		if repo.Visibility == "private" {

+			counts["private"]++

+		}

+		if !repo.IsFork && !repo.IsArchived {

+			counts["source"]++

+		}

+		if repo.IsFork {

+			counts["fork"]++

+		}

+		if repo.IsArchived {

+			counts["archived"]++

+		}

+	}

+	specs := []struct {

+		value string

+		label string

+	}{

+		{value: "all", label: "All"},

+		{value: "public", label: "Public"},

+		{value: "private", label: "Private"},

+		{value: "source", label: "Sources"},

+		{value: "fork", label: "Forks"},

+		{value: "archived", label: "Archived"},

+	}

+	out := make([]orgRepositoryFilterOption, 0, len(specs))

+	for _, spec := range specs {

+		if spec.value == "private" && counts[spec.value] == 0 && selected != spec.value {

+			continue

+		}

+		out = append(out, orgRepositoryFilterOption{

+			Label:    spec.label,

+			Value:    spec.value,

+			Href:     orgRepositoryURL(baseURL, query, spec.value, language, sortKey, 1),

+			Selected: selected == spec.value,

+			Count:    counts[spec.value],

+		})

+	}

+	return out

+}

+

+func orgRepositoryLanguageFilters(baseURL string, repos []orgProfileRepo, query, typeFilter, selected, sortKey string) []orgRepositoryFilterOption {

+	counts := map[string]int{}

+	for _, repo := range repos {

+		if repo.PrimaryLanguage != "" {

+			counts[repo.PrimaryLanguage]++

+		}

+	}

+	languages := make([]string, 0, len(counts))

+	for language := range counts {

+		languages = append(languages, language)

+	}

+	sort.SliceStable(languages, func(i, j int) bool {

+		if counts[languages[i]] != counts[languages[j]] {

+			return counts[languages[i]] > counts[languages[j]]

+		}

+		return languages[i] < languages[j]

+	})

+	out := []orgRepositoryFilterOption{{

+		Label:    "All languages",

+		Value:    "",

+		Href:     orgRepositoryURL(baseURL, query, typeFilter, "", sortKey, 1),

+		Selected: selected == "",

+		Count:    len(repos),

+	}}

+	for _, language := range languages {

+		out = append(out, orgRepositoryFilterOption{

+			Label:    language,

+			Value:    language,

+			Href:     orgRepositoryURL(baseURL, query, typeFilter, language, sortKey, 1),

+			Selected: strings.EqualFold(selected, language),

+			Count:    counts[language],

+		})

+	}

+	return out

+}

+

+func orgRepositorySortOptions(baseURL, query, typeFilter, language, selected string) []orgRepositoryFilterOption {

+	specs := []struct {

+		value string

+		label string

+	}{

+		{value: "updated", label: "Last updated"},

+		{value: "name", label: "Name"},

+		{value: "stars", label: "Stars"},

+	}

+	out := make([]orgRepositoryFilterOption, 0, len(specs))

+	for _, spec := range specs {

+		out = append(out, orgRepositoryFilterOption{

+			Label:    spec.label,

+			Value:    spec.value,

+			Href:     orgRepositoryURL(baseURL, query, typeFilter, language, spec.value, 1),

+			Selected: selected == spec.value,

+		})

+	}

+	return out

+}

+

+func selectedOrgRepositoryOptionLabel(options []orgRepositoryFilterOption, fallback string) string {

+	for _, option := range options {

+		if option.Selected {

+			return option.Label

+		}

+	}

+	return fallback

+}

+

+func orgRepositoryPaginationPages(baseURL, query, typeFilter, language, sortKey string, page, pageCount int) []orgRepositoryPageLink {

+	if pageCount <= 1 {

+		return nil

+	}

+	out := make([]orgRepositoryPageLink, 0, pageCount)

+	for i := 1; i <= pageCount; i++ {

+		out = append(out, orgRepositoryPageLink{

+			Number:  i,

+			Href:    orgRepositoryURL(baseURL, query, typeFilter, language, sortKey, i),

+			Current: i == page,

+		})

+	}

+	return out

+}

+// /{username}, /orgs/{org}/repositories, and /avatars/{username}.

+// Edit-profile is S10.

+	"fmt"

+		"orgs/repositories.html": {Data: []byte(`{{ define "page" }}ORGREPOS={{.Org.Slug}} ACTIVE={{.ActiveOrgNav}} TOTAL={{.RepoCount}} FILTERED={{.FilteredCount}} PAGE={{.Page}}/{{.PageCount}} TYPE={{.SelectedType}} LANG={{.SelectedLanguage}} SORT={{.SelectedSort}} PREV={{.PrevHref}} NEXT={{.NextHref}} NAMES={{range .Repos}}{{.Name}};{{end}}{{range .PaginationPages}} P{{.Number}}={{.Current}}{{end}}{{ end }}`)},

+	h.MountOrgRepositories(r)

+func TestProfile_OrgRepositoriesPagePaginatesVisibleRepos(t *testing.T) {

+	t.Parallel()

+	env := setupProfileEnv(t)

+	creator := env.insertUser(t, "alice", "Alice", "")

+	orgID := env.insertOrg(t, "tenseleyflow", "tenseleyFlow", "workflows", creator)

+	for i := 0; i < 31; i++ {

+		env.insertOrgRepo(t, orgID, fmt.Sprintf("repo-%02d", i), "public repo", "public", "Go", int64(i), 0)

+	}

+	env.insertOrgRepo(t, orgID, "private-roadmap", "hidden", "private", "Rust", 99, 0)

+

+	body := env.getAs(t, "/orgs/tenseleyflow/repositories?sort=name&page=2", usersdb.User{})

+	for _, want := range []string{

+		"ORGREPOS=tenseleyflow",

+		"ACTIVE=repositories",

+		"TOTAL=31",

+		"FILTERED=31",

+		"PAGE=2/2",

+		"SORT=name",

+		"NAMES=repo-30;",

+		"P1=false",

+		"P2=true",

+	} {

+		if !strings.Contains(body, want) {

+			t.Errorf("missing %q in body: %s", want, body)

+		}

+	}

+	if strings.Contains(body, "private-roadmap") || strings.Contains(body, "Rust") {

+		t.Fatalf("anonymous org repositories page leaked private repo data: %s", body)

+	}

+}

+

+func TestProfile_OrgRepositoriesPageFilters(t *testing.T) {

+	t.Parallel()

+	env := setupProfileEnv(t)

+	creator := env.insertUser(t, "alice", "Alice", "")

+	orgID := env.insertOrg(t, "tenseleyflow", "tenseleyFlow", "workflows", creator)

+	env.insertOrgRepo(t, orgID, "shithub", "GitHub clone", "public", "Go", 3, 1, "forge")

+	env.insertOrgRepo(t, orgID, "loader", "local agent loop", "public", "Python", 9, 0, "agents")

+	env.insertOrgRepo(t, orgID, "sway", "adapter research", "public", "Python", 1, 0, "llm")

+

+	body := env.getAs(t, "/orgs/tenseleyflow/repositories?q=agent&type=public&language=Python&sort=stars", usersdb.User{})

+	for _, want := range []string{

+		"FILTERED=1",

+		"TYPE=public",

+		"LANG=Python",

+		"SORT=stars",

+		"NAMES=loader;",

+	} {

+		if !strings.Contains(body, want) {

+			t.Errorf("missing %q in body: %s", want, body)

+		}

+	}

+	if strings.Contains(body, "shithub") || strings.Contains(body, "sway;") {

+		t.Fatalf("org repositories filters returned unexpected repo: %s", body)

+	}

+}

+

+				`href="/orgs/tenseleyFlow/repositories" class="shithub-offcanvas-repo-item"`,

+		deps.OrgRepositoriesMounter = profile.MountOrgRepositories

+.shithub-org-repos-footer {

+  display: flex;

+  justify-content: center;

+  padding: 0.8rem 1rem;

+  border: 1px solid var(--border-default);

+  border-top: 0;

+  border-radius: 0 0 6px 6px;

+  background: var(--canvas-subtle);

+  font-size: 0.875rem;

+  font-weight: 600;

+}

+.shithub-org-repo-list + .shithub-org-repos-footer {

+  margin-top: -1px;

+}

+.shithub-filter-menu a.is-selected {

+  background: var(--canvas-subtle);

+  font-weight: 600;

+}

+.shithub-filter-count {

+  float: right;

+  margin-left: 1rem;

+  color: var(--fg-muted);

+  font-weight: 400;

+}

+

+/* Organization repositories tab. GitHub's current route is

+   /orgs/{org}/repositories: compact pagehead, repo search, dropdown

+   filters, bordered rows, sparklines, and numbered pagination. */

+.shithub-org-repositories-page {

+  max-width: none;

+}

+.shithub-org-repositories-shell {

+  max-width: 1040px;

+  margin: 0 auto;

+  padding: 1.5rem 1rem 2rem;

+}

+.shithub-org-repositories-titlebar {

+  display: flex;

+  align-items: center;

+  justify-content: space-between;

+  gap: 1rem;

+  margin-bottom: 1rem;

+}

+.shithub-org-repositories-titlebar h1 {

+  margin: 0;

+  font-size: 1.5rem;

+  line-height: 1.25;

+}

+.shithub-org-repositories-titlebar p {

+  margin: 0.25rem 0 0;

+  color: var(--fg-muted);

+  font-size: 0.875rem;

+}

+.shithub-org-repositories-toolbar {

+  display: grid;

+  grid-template-columns: minmax(240px, 1fr) auto;

+  gap: 0.75rem;

+  align-items: center;

+  padding-bottom: 1rem;

+  border-bottom: 1px solid var(--border-default);

+}

+.shithub-org-repositories-search {

+  position: relative;

+  min-width: 0;

+}

+.shithub-org-repositories-search > span {

+  position: absolute;

+  left: 0.7rem;

+  top: 50%;

+  display: inline-flex;

+  color: var(--fg-muted);

+  transform: translateY(-50%);

+  pointer-events: none;

+}

+.shithub-org-repositories-search input[type="search"] {

+  width: 100%;

+  min-height: 34px;

+  padding: 0.35rem 0.75rem 0.35rem 2rem;

+  border: 1px solid var(--border-default);

+  border-radius: 6px;

+  background: var(--canvas-default);

+  color: var(--fg-default);

+}

+.shithub-org-repositories-filters {

+  display: flex;

+  align-items: center;

+  justify-content: flex-end;

+  gap: 0.5rem;

+  flex-wrap: wrap;

+}

+.shithub-org-repositories-filters .shithub-filter-menu[open] > div {

+  min-width: 190px;

+}

+.shithub-org-repositories-filters .shithub-filter-menu summary span {

+  color: var(--fg-muted);

+  font-weight: 400;

+}

+.shithub-org-repositories-list {

+  margin-top: 0;

+  border-top: 0;

+  border-radius: 0 0 6px 6px;

+}

+.shithub-org-repositories-empty {

+  margin-top: 1rem;

+}

+.shithub-org-repositories-empty h2 {

+  margin: 0 0 0.55rem;

+  color: var(--fg-default);

+  font-size: 1.1rem;

+}

+.shithub-org-repositories-empty p {

+  margin: 0;

+}

+.shithub-org-repositories-pagination {

+  display: flex;

+  justify-content: center;

+  gap: 0.35rem;

+  padding: 1.25rem 0 0;

+}

+.shithub-org-repositories-pagination a,

+.shithub-org-repositories-pagination span {

+  display: inline-flex;

+  align-items: center;

+  justify-content: center;

+  min-width: 34px;

+  min-height: 32px;

+  padding: 0.35rem 0.7rem;

+  border: 1px solid var(--border-default);

+  border-radius: 6px;

+  background: var(--canvas-default);

+  color: var(--fg-default);

+  font-size: 0.875rem;

+  font-weight: 600;

+}

+.shithub-org-repositories-pagination a:hover {

+  background: var(--canvas-subtle);

+  text-decoration: none;

+}

+.shithub-org-repositories-pagination .is-current {

+  border-color: var(--accent-emphasis);

+  background: var(--accent-emphasis);

+  color: #fff;

+}

+.shithub-org-repositories-pagination .is-disabled {

+  color: var(--fg-muted);

+  opacity: 0.65;

+}

+  .shithub-org-repo-head,

+  .shithub-org-repositories-toolbar {

+  .shithub-org-repo-actions,

+  .shithub-org-repositories-filters {

+        <a href="/orgs/{{ .Org.Slug }}/repositories" class="shithub-offcanvas-repo-item">

+      <a href="/orgs/{{ .Org.Slug }}/repositories" class="shithub-offcanvas-show-more">Show more</a>

+  <a href="/orgs/{{ .Org.Slug }}/repositories" class="shithub-org-nav-item{{ if eq .ActiveOrgNav "repositories" }} is-active{{ end }}">

+          <form action="{{ .OrgRepositoriesURL }}" method="get" role="search" class="shithub-org-repo-search">

+              <div><a href="{{ .OrgRepositoriesURL }}">All</a><a href="{{ .OrgRepositoriesURL }}?type=public">Public</a><a href="{{ .OrgRepositoriesURL }}?type=source">Sources</a><a href="{{ .OrgRepositoriesURL }}?type=fork">Forks</a><a href="{{ .OrgRepositoriesURL }}?type=archived">Archived</a></div>

+              <div><a href="{{ .OrgRepositoriesURL }}">All</a>{{ range .TopLanguages }}<a href="{{ $.OrgRepositoriesURL }}?language={{ urlquery .Name }}">{{ .Name }}</a>{{ end }}</div>

+              <div><a href="{{ .OrgRepositoriesURL }}">Last updated</a><a href="{{ .OrgRepositoriesURL }}?sort=name">Name</a><a href="{{ .OrgRepositoriesURL }}?sort=stars">Stars</a></div>

+        {{ if .HasMoreRepos }}

+        <div class="shithub-org-repos-footer">

+          <a href="{{ .OrgRepositoriesURL }}">View all repositories</a>

+        </div>

+        {{ end }}

+{{ define "page" -}}

+<section class="shithub-org-repositories-page">

+  <header class="shithub-org-pagehead">

+    <div class="shithub-org-pagehead-inner">

+      <a class="shithub-org-pagehead-title" href="/{{ .Org.Slug }}">

+        <img src="{{ .AvatarURL }}" alt="" width="30" height="30">

+        <span>{{ if .Org.DisplayName }}{{ .Org.DisplayName }}{{ else }}{{ .Org.Slug }}{{ end }}</span>

+      </a>

+    </div>

+    {{ template "org-subnav" . }}

+  </header>

+

+  <main class="shithub-org-repositories-shell">

+    <div class="shithub-org-repositories-titlebar">

+      <div>

+        <h1>Repositories</h1>

+        <p>

+          {{ if .HasActiveFilters }}

+            {{ .FilteredCount }} result{{ if ne .FilteredCount 1 }}s{{ end }}

+          {{ else }}

+            {{ .RepoCount }} repositor{{ if eq .RepoCount 1 }}y{{ else }}ies{{ end }}

+          {{ end }}

+        </p>

+      </div>

+      {{ if .CanCreateRepo }}<a href="/new?owner={{ .Org.Slug }}" class="shithub-button shithub-button-primary">{{ octicon "repo" }} New</a>{{ end }}

+    </div>

+

+    <div class="shithub-org-repositories-toolbar">

+      <form action="/orgs/{{ .Org.Slug }}/repositories" method="get" role="search" class="shithub-org-repositories-search">

+        <span aria-hidden="true">{{ octicon "search" }}</span>

+        <label class="sr-only" for="org-repositories-search">Find a repository</label>

+        <input id="org-repositories-search" type="search" name="q" value="{{ .Query }}" placeholder="Find a repository...">

+        {{ if ne .SelectedType "all" }}<input type="hidden" name="type" value="{{ .SelectedType }}">{{ end }}

+        {{ if .SelectedLanguage }}<input type="hidden" name="language" value="{{ .SelectedLanguage }}">{{ end }}

+        {{ if ne .SelectedSort "updated" }}<input type="hidden" name="sort" value="{{ .SelectedSort }}">{{ end }}

+      </form>

+

+      <div class="shithub-org-repositories-filters">

+        <details class="shithub-filter-menu">

+          <summary>Type: <span>{{ .SelectedTypeLabel }}</span> {{ octicon "triangle-down" }}</summary>

+          <div>

+            {{ range .TypeFilters }}

+            <a href="{{ .Href }}" class="{{ if .Selected }}is-selected{{ end }}">{{ .Label }} <span class="shithub-filter-count">{{ .Count }}</span></a>

+            {{ end }}

+          </div>

+        </details>

+        <details class="shithub-filter-menu">

+          <summary>Language: <span>{{ .SelectedLanguageLabel }}</span> {{ octicon "triangle-down" }}</summary>

+          <div>

+            {{ range .LanguageFilters }}

+            <a href="{{ .Href }}" class="{{ if .Selected }}is-selected{{ end }}">{{ .Label }} <span class="shithub-filter-count">{{ .Count }}</span></a>

+            {{ end }}

+          </div>

+        </details>

+        <details class="shithub-filter-menu">

+          <summary>Sort: <span>{{ .SelectedSortLabel }}</span> {{ octicon "triangle-down" }}</summary>

+          <div>

+            {{ range .SortOptions }}

+            <a href="{{ .Href }}" class="{{ if .Selected }}is-selected{{ end }}">{{ .Label }}</a>

+            {{ end }}

+          </div>

+        </details>

+      </div>

+    </div>

+

+    {{ if .Repos }}

+    <ul class="shithub-org-repo-list shithub-org-repositories-list">

+    {{ range .Repos }}

+      <li class="shithub-org-repo-row">

+        <div class="shithub-org-repo-row-main">

+          <h3>

+            <a href="/{{ $.Org.Slug }}/{{ .Name }}">{{ .Name }}</a>

+            {{ if eq .Visibility "private" }}<span class="shithub-pill shithub-pill-private">Private</span>{{ else }}<span class="shithub-pill">Public</span>{{ end }}

+            {{ if .IsArchived }}<span class="shithub-pill shithub-pill-archived">Archived</span>{{ end }}

+          </h3>

+          {{ if .Description }}<p>{{ .Description }}</p>{{ end }}

+          {{ if .Topics }}

+          <div class="shithub-org-row-topics">

+            {{ range .Topics }}<a href="/search?q=topic:{{ . }}&amp;type=repositories" class="shithub-topic">{{ . }}</a>{{ end }}

+          </div>

+          {{ end }}

+          <div class="shithub-org-repo-meta">

+            {{ if .PrimaryLanguage }}<span><span class="shithub-language-dot" style="background-color: {{ .PrimaryLanguageColor }};"></span>{{ .PrimaryLanguage }}</span>{{ end }}

+            {{ if .LicenseKey }}<span>{{ octicon "law" }} {{ .LicenseKey }}</span>{{ end }}

+            <span>{{ octicon "star" }} {{ .StarCount }}</span>

+            <span>{{ octicon "repo-forked" }} {{ .ForkCount }}</span>

+            <time datetime="{{ .UpdatedAt.Format "2006-01-02T15:04:05Z" }}">Updated {{ relativeTime .UpdatedAt }}</time>

+          </div>

+        </div>

+        {{ .ActivitySparkline }}

+      </li>

+    {{ end }}

+    </ul>

+    {{ else }}

+    <div class="shithub-org-empty shithub-org-repositories-empty">

+      {{ if .HasActiveFilters }}

+      <h2>No repositories matched your search.</h2>

+      <p>Try another search term or a different filter.</p>

+      {{ else }}

+      <h2>No repositories yet.</h2>

+      {{ if .CanCreateRepo }}<a href="/new?owner={{ .Org.Slug }}" class="shithub-button shithub-button-primary">Create a repository</a>{{ end }}

+      {{ end }}

+    </div>

+    {{ end }}

+

+    {{ if gt .PageCount 1 }}

+    <nav class="shithub-org-repositories-pagination" aria-label="Pagination">

+      {{ if .HasPrev }}<a href="{{ .PrevHref }}">Previous</a>{{ else }}<span class="is-disabled" aria-disabled="true">Previous</span>{{ end }}

+      {{ range .PaginationPages }}

+        {{ if .Current }}<span class="is-current" aria-current="page">{{ .Number }}</span>{{ else }}<a href="{{ .Href }}">{{ .Number }}</a>{{ end }}

+      {{ end }}

+      {{ if .HasNext }}<a href="{{ .NextHref }}">Next</a>{{ else }}<span class="is-disabled" aria-disabled="true">Next</span>{{ end }}

+    </nav>

+    {{ end }}

+  </main>

+</section>

+{{- end }}

+      <a href="/orgs/{{ .Org.Slug }}/repositories" class="shithub-org-nav-item">{{ octicon "repo" }} Repositories</a>