@dxos/plugin-github 0.7.4 → 0.13.0

package/dist/lib/chunk-PullRequestsArticle.mjs

@@ -0,0 +1,594 @@
+import { t as useOpenObject } from "./chunk-useOpenObject.mjs";
+import { meta } from "#meta";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { GitHubOperation } from "#types";
+import { PullRequest, Task } from "@dxos/types";
+import { Filter, Obj, Ref, Tag, Type } from "@dxos/echo";
+import * as Schema from "effect/Schema";
+import { log } from "@dxos/log";
+import * as UiHooks from "@dxos/react-ui/Hooks";
+import * as Layout from "@dxos/react-ui/Layout";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useQuery } from "@dxos/echo-react";
+import * as Hooks from "@dxos/app-framework/Hooks";
+import { GroupMenu, SortMenu } from "@dxos/react-ui-menu";
+import * as Panel from "@dxos/react-ui/Panel";
+import * as Button from "@dxos/react-ui/Button";
+import { Listbox } from "@dxos/react-ui-list";
+import * as Status from "@dxos/react-ui/Status";
+import * as Icon from "@dxos/react-ui/Icon";
+import { useAtomValue } from "@effect/atom-react/Hooks";
+import * as Atom from "effect/reactivity/Atom";
+import { QueryBuilder, matchesFilter } from "@dxos/echo-query";
+import { useAttention, useViewState, useViewStateActions } from "@dxos/react-ui-attention";
+import { QueryEditor, usePersistentQuery } from "@dxos/react-ui-query";
+import * as Toolbar from "@dxos/react-ui/Toolbar";
+import { ViewState } from "@dxos/react-ui-attention/types";
+//#region src/hooks/usePullRequestChecks.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-github/src/hooks/usePullRequestChecks.ts";
+/** How long a pull request's checks stand before they are read from GitHub again. */
+var CHECKS_INTERVAL = 3e5;
+/** Status reads in flight at once: each costs three GitHub requests, and a list can hold hundreds. */
+var CONCURRENCY = 4;
+var cache = /* @__PURE__ */ new Map();
+/** Whether a pull request's checks still change; a merged or closed one's head is settled. */
+var isLive = (pullRequest) => pullRequest.state === "open" || pullRequest.state === "draft";
+/**
+* The CI and review standing of every live pull request in `pullRequests`, keyed by object id and
+* filled in as each read lands. Finished pull requests are not read: their checks no longer ask
+* anything of the reader.
+*/
+var usePullRequestChecks = (pullRequests, spaceId) => {
+	const { invokePromise } = Hooks.useOperationInvoker();
+	const [checks, setChecks] = useState(() => new Map([...cache].map(([id, { checks }]) => [id, checks])));
+	useEffect(() => {
+		if (!spaceId) return;
+		let cancelled = false;
+		const now = Date.now();
+		const queue = pullRequests.filter((pullRequest) => isLive(pullRequest) && now - (cache.get(pullRequest.id)?.at ?? 0) >= CHECKS_INTERVAL);
+		const worker = async () => {
+			for (let pullRequest = queue.shift(); pullRequest && !cancelled; pullRequest = queue.shift()) {
+				const { data, error } = await invokePromise(GitHubOperation.GetPullRequestStatus, { pullRequest: Ref.make(pullRequest) }, { spaceId });
+				if (error || !data) {
+					log.warn("pull request checks failed", {
+						pullRequest: pullRequest.id,
+						error
+					}, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file,
+						L: 62,
+						S: void 0
+					});
+					continue;
+				}
+				const next = {
+					ci: data.ci,
+					checks: data.checks,
+					review: data.review,
+					approvals: data.approvals
+				};
+				cache.set(pullRequest.id, {
+					at: Date.now(),
+					checks: next
+				});
+				const id = pullRequest.id;
+				setChecks((previous) => new Map(previous).set(id, next));
+			}
+		};
+		Promise.all(Array.from({ length: Math.min(CONCURRENCY, queue.length) }, worker));
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		invokePromise,
+		pullRequests,
+		spaceId
+	]);
+	return checks;
+};
+//#endregion
+//#region src/types/PullRequestsView.ts
+/**
+* The fields the pull request list can be ordered by. `relevance` ranks what needs the reader first
+* (see `relevance`); `updated` and `created` are GitHub's times.
+*/
+var SortField = Schema.Literals([
+	"relevance",
+	"updated",
+	"created",
+	"number",
+	"title"
+]);
+var SortDirection = Schema.Literals(["asc", "desc"]);
+var Sort = Schema.Struct({
+	field: SortField,
+	direction: SortDirection
+});
+/** The fields the list can be grouped by; `none` is one ungrouped list. */
+var GroupField = Schema.Literals([
+	"none",
+	"repo",
+	"state",
+	"checks",
+	"author"
+]);
+var DEFAULT_SORT = {
+	field: "relevance",
+	direction: "desc"
+};
+var View = Schema.Struct({
+	query: Schema.String,
+	sort: Schema.optional(Sort),
+	group: Schema.optional(GroupField)
+});
+/**
+* How a reader has the space's pull requests arranged, keyed by the space and held per device
+* (`local`), as a task set's list is: the filter, order and grouping are how this reader looks at the
+* list here, not a property of the space every member would see.
+*/
+var aspect = ViewState.define({
+	key: "github-pull-requests-view",
+	backend: "local",
+	schema: View,
+	defaultValue: () => ({ query: "" })
+});
+//#endregion
+//#region src/containers/PullRequestsArticle/arrange.ts
+/** What a free-text term searches: what a reader sees in the row. */
+var rowText = (pullRequest) => [
+	pullRequest.title,
+	PullRequest.reference(pullRequest),
+	pullRequest.author,
+	pullRequest.headBranch
+];
+/** The rows the toolbar's query keeps, in input order; an absent filter keeps every row. */
+var filterRows = (rows, filter) => filter ? rows.filter(({ pullRequest }) => matchesFilter(filter, pullRequest, { text: rowText })) : rows;
+var STATE_WEIGHT = {
+	open: 1e3,
+	draft: 600,
+	merged: 100,
+	closed: 0
+};
+/**
+* How much a row asks of the reader now: an open pull request outranks a draft, which outranks a
+* finished one; within those, red CI or requested changes (something to fix) outrank one ready to
+* merge, which outranks one still waiting; and a pull request some task tracks is nudged up.
+*/
+var relevance = ({ pullRequest, checks, tasks }) => {
+	let score = STATE_WEIGHT[pullRequest.state];
+	if (pullRequest.state === "open" || pullRequest.state === "draft") {
+		if (checks?.ci === "failure") score += 300;
+		if (checks?.review === "changes_requested") score += 250;
+		if (checks?.review === "approved" && checks.ci !== "failure" && checks.ci !== "pending") score += 200;
+		if (checks?.ci === "pending") score += 50;
+	}
+	if (tasks.length > 0) score += 25;
+	return score;
+};
+var time = (value) => {
+	const parsed = value ? Date.parse(value) : NaN;
+	return Number.isNaN(parsed) ? 0 : parsed;
+};
+/** Newest activity GitHub reported, falling back to when it was opened. */
+var activity = (pullRequest) => time(pullRequest.updatedAt) || time(pullRequest.createdAt);
+var byRecency = (left, right) => activity(left.pullRequest) - activity(right.pullRequest) || left.pullRequest.number - right.pullRequest.number;
+var compareBy = {
+	relevance: (left, right) => relevance(left) - relevance(right) || byRecency(left, right),
+	updated: byRecency,
+	created: (left, right) => time(left.pullRequest.createdAt) - time(right.pullRequest.createdAt) || left.pullRequest.number - right.pullRequest.number,
+	number: (left, right) => left.pullRequest.number - right.pullRequest.number,
+	title: (left, right) => (left.pullRequest.title ?? "").localeCompare(right.pullRequest.title ?? "", void 0, { sensitivity: "base" })
+};
+/** The rows reordered by `sort`, ties kept in input order. */
+var sortRows = (rows, sort) => {
+	const compare = compareBy[sort.field];
+	const sign = sort.direction === "desc" ? -1 : 1;
+	const index = new Map(rows.map((row, position) => [row.pullRequest.id, position]));
+	return [...rows].sort((left, right) => sign * compare(left, right) || (index.get(left.pullRequest.id) ?? 0) - (index.get(right.pullRequest.id) ?? 0));
+};
+var STATE_ORDER = [
+	"open",
+	"draft",
+	"merged",
+	"closed"
+];
+var STATE_ICON = {
+	open: "ph--git-pull-request--regular",
+	draft: "ph--git-pull-request--regular",
+	merged: "ph--git-merge--regular",
+	closed: "ph--x-circle--regular"
+};
+var STATE_HUE = {
+	open: "green",
+	closed: "red",
+	merged: "purple",
+	draft: "neutral"
+};
+var CI_ORDER = [
+	"failure",
+	"pending",
+	"success",
+	"none"
+];
+var CI_ICON = {
+	failure: "ph--x-circle--regular",
+	pending: "ph--circle-notch--regular",
+	success: "ph--check-circle--regular",
+	none: "ph--minus-circle--regular"
+};
+var CI_HUE = {
+	success: "green",
+	failure: "red",
+	pending: "amber",
+	none: "neutral"
+};
+/** Rows partitioned by a string key, groups in first-seen order unless `order` ranks them; empty groups dropped. */
+var partition = (rows, key, make, order) => {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const value = key(row);
+		byKey.set(value, [...byKey.get(value) ?? [], row]);
+	}
+	const keys = [...byKey.keys()];
+	if (order) keys.sort(order);
+	return keys.map((value) => make(value, byKey.get(value) ?? []));
+};
+var rankOf = (values) => (left, right) => values.indexOf(left) - values.indexOf(right);
+/**
+* The rows partitioned by `field`, each group's rows in input order (so a sort applies within every
+* group). Absent for `none`: an ungrouped list has no headers.
+*/
+var groupRows = (rows, field) => {
+	switch (field) {
+		case "none": return;
+		case "repo": return partition(rows, ({ pullRequest }) => `${pullRequest.owner}/${pullRequest.repo}`, (repo, rows) => ({
+			id: `repo-${repo}`,
+			label: repo,
+			icon: "ph--git-branch--regular",
+			rows
+		}), (left, right) => left.localeCompare(right));
+		case "state": return partition(rows, ({ pullRequest }) => pullRequest.state, (state, rows) => ({
+			id: `state-${state}`,
+			label: `pull-request-state.${state}.label`,
+			translate: true,
+			icon: STATE_ICON[state],
+			hue: STATE_HUE[state],
+			rows
+		}), rankOf(STATE_ORDER));
+		case "checks": return [...partition(rows.filter((row) => row.checks), ({ checks }) => checks?.ci ?? "none", (ci, rows) => ({
+			id: `checks-${ci}`,
+			label: `ci-status.${ci}.label`,
+			translate: true,
+			icon: CI_ICON[ci],
+			hue: CI_HUE[ci],
+			rows
+		}), rankOf(CI_ORDER)), ...partition(rows.filter((row) => !row.checks), () => "unknown", (_, rows) => ({
+			id: "checks-unknown",
+			label: "ci-status.unknown.label",
+			translate: true,
+			icon: "ph--question--regular",
+			rows
+		}))];
+		case "author": return partition(rows, ({ pullRequest }) => pullRequest.author ?? "", (author, rows) => ({
+			id: `author-${author}`,
+			label: author || "group-no-author.label",
+			translate: !author,
+			icon: author ? "ph--user--regular" : "ph--user-circle-dashed--regular",
+			rows
+		}), (left, right) => left === "" ? 1 : right === "" ? -1 : left.localeCompare(right));
+	}
+};
+//#endregion
+//#region src/containers/PullRequestsArticle/format.ts
+var UNITS = [
+	["year", 31536e6],
+	["month", 2592e6],
+	["week", 6048e5],
+	["day", 864e5],
+	["hour", 36e5],
+	["minute", 6e4]
+];
+var formatter;
+/** `5 minutes ago`, `yesterday`, `3 weeks ago` — in the largest unit that fits; empty for an invalid date. */
+var formatRelative = (value, now = Date.now()) => {
+	const date = Date.parse(value);
+	if (Number.isNaN(date)) return "";
+	formatter ??= new Intl.RelativeTimeFormat(void 0, { numeric: "auto" });
+	const elapsed = date - now;
+	for (const [unit, size] of UNITS) if (Math.abs(elapsed) >= size) return formatter.format(Math.round(elapsed / size), unit);
+	return formatter.format(0, "minute");
+};
+//#endregion
+//#region src/containers/PullRequestsArticle/PullRequestsArticle.tsx
+var PULL_REQUEST_TYPENAME = Type.getTypename(PullRequest.PullRequest);
+var SORT_ICONS = {
+	relevance: "ph--lightning--regular",
+	updated: "ph--clock-clockwise--regular",
+	created: "ph--calendar-plus--regular",
+	number: "ph--hash--regular",
+	title: "ph--text-aa--regular"
+};
+var GROUP_ICONS = {
+	none: "ph--list--regular",
+	repo: "ph--git-branch--regular",
+	state: "ph--git-pull-request--regular",
+	checks: "ph--check-circle--regular",
+	author: "ph--user--regular"
+};
+/**
+* Every pull request in a space as one list a reader triages from: repository, title, CI checks,
+* the tasks that track it and its state, ordered by relevance (what needs the reader first) or time.
+* The filter, order and grouping persist per device and per space, through the same view-state
+* aspect, query editor and sort/group menus a task set's list uses.
+*/
+var PullRequestsArticle = ({ db, ...props }) => db ? /* @__PURE__ */ jsx(PullRequestList, {
+	db,
+	...props
+}) : null;
+PullRequestsArticle.displayName = "PullRequestsArticle";
+var PullRequestList = ({ role, attendableId, db }) => {
+	const { t } = UiHooks.useTranslation(meta.profile.key);
+	const { hasAttention } = useAttention(attendableId);
+	const editorRef = useRef(null);
+	const contextId = db.spaceId;
+	const [query, setQuery] = usePersistentQuery(aspect, contextId, editorRef);
+	const { sort = DEFAULT_SORT, group = "none" } = useViewState(aspect, contextId);
+	const { update } = useViewStateActions(aspect, contextId);
+	const handleSortChange = useCallback((sort) => update((view) => ({
+		...view,
+		sort
+	})), [update]);
+	const handleGroupChange = useCallback((group) => update((view) => ({
+		...view,
+		group
+	})), [update]);
+	const handleClear = useCallback(() => setQuery(""), [setQuery]);
+	const tags = useTagMap(db);
+	const filter = useMemo(() => {
+		const text = query.trim();
+		return text.length === 0 ? void 0 : new QueryBuilder(tags).build(text).filter ?? Filter.nothing();
+	}, [query, tags]);
+	const pullRequests = useQuery(db, Filter.type(PullRequest.PullRequest));
+	const { rows, groups } = useArrangedRows(pullRequests, useQuery(db, Filter.type(Task.Task)), usePullRequestChecks(pullRequests, db.spaceId), {
+		filter,
+		sort,
+		group
+	});
+	const options = useMemo(() => (groups ? groups.flatMap((group) => group.rows) : rows).map(({ pullRequest }) => ({
+		value: pullRequest.id,
+		label: pullRequest.title
+	})), [groups, rows]);
+	const sortFields = useMemo(() => SortField.literals.map((id) => ({
+		id,
+		label: t(`pull-requests-sort-${id}.label`),
+		icon: SORT_ICONS[id]
+	})), [t]);
+	const directionLabels = useMemo(() => ({
+		asc: t("pull-requests-sort-asc.label"),
+		desc: t("pull-requests-sort-desc.label")
+	}), [t]);
+	const groupFields = useMemo(() => GroupField.literals.map((id) => ({
+		id,
+		label: t(`pull-requests-group-${id}.label`),
+		icon: GROUP_ICONS[id]
+	})), [t]);
+	const openObject = useOpenObject();
+	return /* @__PURE__ */ jsxs(Panel.Root, {
+		role,
+		"data-testid": "pull-requests",
+		children: [/* @__PURE__ */ jsx(Panel.Header, { children: /* @__PURE__ */ jsxs(Toolbar.Root, {
+			inactive: !hasAttention,
+			children: [
+				/* @__PURE__ */ jsx(QueryEditor, {
+					classNames: "grow min-w-0 ps-1",
+					db,
+					tags,
+					value: query,
+					onChange: setQuery,
+					ref: editorRef
+				}),
+				/* @__PURE__ */ jsx(SortMenu, {
+					fields: sortFields,
+					value: sort,
+					onChange: handleSortChange,
+					label: t("pull-requests-sort.label"),
+					directionLabels,
+					testId: "pull-requests.sort"
+				}),
+				/* @__PURE__ */ jsx(GroupMenu, {
+					fields: groupFields,
+					value: group,
+					onChange: handleGroupChange,
+					label: t("pull-requests-group.label"),
+					none: "none",
+					testId: "pull-requests.group"
+				}),
+				/* @__PURE__ */ jsx(Button.Root, {
+					icon: "ph--x--regular",
+					iconOnly: true,
+					disabled: query.trim().length === 0,
+					label: t("pull-requests-filter-clear.label"),
+					"data-testid": "pull-requests.filter.clear",
+					onClick: handleClear
+				})
+			]
+		}) }), /* @__PURE__ */ jsx(Panel.Body, { children: rows.length === 0 ? /* @__PURE__ */ jsx(Status.Empty, {
+			classNames: "dx-expand",
+			children: t(pullRequests.length === 0 ? "pull-requests-empty.message" : "pull-requests-no-match.message")
+		}) : /* @__PURE__ */ jsx(Listbox.Root, {
+			items: options,
+			children: /* @__PURE__ */ jsx(Listbox.Content, {
+				classNames: "dx-expand",
+				"aria-label": t("typename.label_other", { ns: PULL_REQUEST_TYPENAME }),
+				children: groups ? groups.filter((group) => group.rows.length > 0).map((group) => /* @__PURE__ */ jsx(GroupSection, {
+					group,
+					onOpen: openObject
+				}, group.id)) : rows.map((row) => /* @__PURE__ */ jsx(PullRequestListRow, {
+					row,
+					onOpen: openObject
+				}, row.pullRequest.id))
+			})
+		}) })]
+	});
+};
+var GroupSection = ({ group, onOpen }) => {
+	const { t } = UiHooks.useTranslation(meta.profile.key);
+	return /* @__PURE__ */ jsxs(Listbox.ItemGroup, { children: [/* @__PURE__ */ jsx(Listbox.ItemGroupLabel, { children: /* @__PURE__ */ jsxs(Layout.Flex, {
+		align: "center",
+		gap: "sm",
+		children: [
+			/* @__PURE__ */ jsx(Icon.Icon, {
+				icon: group.icon,
+				classNames: "dx-text",
+				"data-hue": group.hue
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "truncate",
+				children: group.translate ? t(group.label) : group.label
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "text-description",
+				children: group.rows.length
+			})
+		]
+	}) }), group.rows.map((row) => /* @__PURE__ */ jsx(PullRequestListRow, {
+		row,
+		onOpen
+	}, row.pullRequest.id))] });
+};
+/** One pull request: its repository and number, title, author and time, then checks, tasks and state. */
+var PullRequestListRow = ({ row: { pullRequest, checks, tasks }, onOpen }) => {
+	const { t } = UiHooks.useTranslation(meta.profile.key);
+	const time = pullRequest.updatedAt ?? pullRequest.createdAt;
+	return /* @__PURE__ */ jsx(Listbox.Item, {
+		id: pullRequest.id,
+		classNames: "cursor-pointer py-2",
+		"data-testid": "pull-requests.row",
+		onClick: () => void onOpen(pullRequest),
+		children: /* @__PURE__ */ jsxs(Layout.Flex, {
+			column: true,
+			gap: "xs",
+			grow: true,
+			children: [/* @__PURE__ */ jsxs(Layout.Flex, {
+				align: "center",
+				gap: "sm",
+				classNames: "min-w-0",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "dx-tag dx-tag-inline shrink-0",
+						"data-hue": "neutral",
+						children: PullRequest.reference(pullRequest)
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "truncate grow",
+						children: pullRequest.title
+					}),
+					/* @__PURE__ */ jsx(ChecksTag, {
+						pullRequest,
+						checks
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "dx-tag dx-tag-inline shrink-0",
+						"data-hue": STATE_HUE[pullRequest.state],
+						"data-testid": "pull-requests.row.state",
+						children: t(`pull-request-state.${pullRequest.state}.label`)
+					})
+				]
+			}), /* @__PURE__ */ jsxs(Layout.Flex, {
+				align: "center",
+				gap: "sm",
+				classNames: "min-w-0 text-xs text-description",
+				children: [
+					pullRequest.author && /* @__PURE__ */ jsx("span", {
+						className: "shrink-0",
+						children: pullRequest.author
+					}),
+					time && /* @__PURE__ */ jsx("time", {
+						className: "shrink-0",
+						dateTime: time,
+						title: new Date(time).toLocaleString(),
+						children: formatRelative(time)
+					}),
+					tasks.length > 0 && /* @__PURE__ */ jsxs(Layout.Flex, {
+						align: "center",
+						gap: "xs",
+						classNames: "min-w-0",
+						"data-testid": "pull-requests.row.tasks",
+						children: [/* @__PURE__ */ jsx(Icon.Icon, {
+							icon: "ph--check-square-offset--regular",
+							size: "xs",
+							classNames: "shrink-0"
+						}), /* @__PURE__ */ jsx("span", {
+							className: "truncate",
+							children: tasks.map((task) => task.title || t("untitled-task.label")).join(", ")
+						})]
+					})
+				]
+			})]
+		})
+	});
+};
+var ChecksTag = ({ pullRequest, checks }) => {
+	const { t } = UiHooks.useTranslation(meta.profile.key);
+	if (!checks) return pullRequest.state === "open" || pullRequest.state === "draft" ? /* @__PURE__ */ jsx("span", {
+		className: "dx-tag dx-tag-inline",
+		"data-hue": "neutral",
+		"data-testid": "pull-requests.row.checks",
+		children: t("ci-status.unknown.label")
+	}) : null;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [checks.review !== "none" && /* @__PURE__ */ jsx("span", {
+		className: "dx-tag dx-tag-inline",
+		"data-hue": checks.review === "approved" ? "green" : "red",
+		"data-testid": "pull-requests.row.review",
+		children: t(`review-status.${checks.review}.label`, { count: checks.approvals })
+	}), /* @__PURE__ */ jsxs("span", {
+		className: "dx-tag dx-tag-inline",
+		"data-hue": CI_HUE[checks.ci],
+		"data-testid": "pull-requests.row.checks",
+		children: [t(`ci-status.${checks.ci}.label`), checks.checks.total > 0 && ` ${checks.checks.passed}/${checks.checks.total}`]
+	})] });
+};
+/**
+* The rows the toolbar keeps, in the order it asks for, partitioned into its groups. Read through
+* atoms so a re-sync (a new state, a new title) or a task gaining the pull request as an artifact
+* re-arranges the list without the queries re-emitting.
+*/
+var useArrangedRows = (pullRequests, tasks, checks, { filter, sort, group }) => {
+	const atom = useMemo(() => Atom.make((get) => {
+		pullRequests.forEach((pullRequest) => get(Obj.atom(pullRequest)));
+		const tasksByPullRequest = /* @__PURE__ */ new Map();
+		for (const task of tasks) for (const ref of get(Obj.atomProperty(task, "artifacts")) ?? []) {
+			const id = Task.refEntityId(ref);
+			if (id) tasksByPullRequest.set(id, [...tasksByPullRequest.get(id) ?? [], task]);
+		}
+		const rows = sortRows(filterRows(pullRequests.map((pullRequest) => ({
+			pullRequest,
+			checks: checks.get(pullRequest.id),
+			tasks: tasksByPullRequest.get(pullRequest.id) ?? []
+		})), filter), sort);
+		return {
+			rows,
+			groups: groupRows(rows, group)
+		};
+	}), [
+		pullRequests,
+		tasks,
+		checks,
+		filter,
+		sort,
+		group
+	]);
+	return useAtomValue(atom);
+};
+/** Tag registry keyed by the `Tag` object's uri — the id space `#tag` terms and `meta.tags` share. */
+var useTagMap = (db) => {
+	const tags = useQuery(db, Filter.type(Tag.Tag));
+	return useMemo(() => tags.reduce((acc, tag) => {
+		acc[Obj.getURI(tag).toString()] = tag;
+		return acc;
+	}, {}), [tags]);
+};
+//#endregion
+export { PullRequestsArticle as default };
+
+//# sourceMappingURL=chunk-PullRequestsArticle.mjs.map