Community-driven data and tools for the Angular ecosystem — hub.openng.org. Every dataset is a file anyone can improve with a pull request, and the site is one consumer of those packages among others to come (a CLI, an MCP server).
Events, Communities and Podcasts (from angular-hub), Can I Use (feature statuses per version, ng update migrations, the Angular MCP server catalog, angular-eslint rules), Release insights (what each major brought, with every commit) and Library health (which Angular majors a library supports, and a score, experimental for now), from angular.courses. An OpenNG project.
Contributions are welcome, data first: see CONTRIBUTING.md. Code is MIT (LICENSE); data is CC BY 4.0 (LICENSE-DATA); third-party credits are in ATTRIBUTION.md.
| Path | What it is |
|---|---|
apps/web |
The site: Angular 22, SSR + prerender, Optimus UI, Tailwind v4 |
packages/data-caniuse |
Curated feature statuses, deprecated public APIs, ng update migrations, ESLint rules, MCP server tools |
packages/core-angular-versions |
Angular majors, release dates and support windows, semver helpers, Node/TypeScript/RxJS compatibility |
packages/data-community |
Angular events worldwide, the communities running them, podcasts |
packages/data-libraries |
The Angular libraries the hub tracks, their health data and the health score (HEALTH_SCORE.md) |
packages/data-releases |
Release announcements, GitHub releases, the commits of every stable release, migration guides |
packages/data-sync |
pnpm data:sync: regenerates the datasets read from Angular's repositories, npm and GitHub |
Packages are framework-free TypeScript: they run in the browser, in Node, in a CLI and in an MCP
server. All Angular code lives in apps/web.
Prerequisites: Node.js 22 LTS (22.22.3 or later; .nvmrc) or 24.15+, and pnpm through corepack
(corepack enable installs the version pinned in package.json). No database. A GitHub token is
optional: the data sync and the live package check run without one, within GitHub's anonymous rate
limit (see Generated datasets).
corepack enable
pnpm install
pnpm dev # the site with SSR at http://localhost:4200
pnpm test # vitest everywhere (ng test for the app)
pnpm lint # ESLint (angular-eslint)
pnpm check-types
pnpm format # Prettier
pnpm build # packages (tsup) then the site: prerendered pages, sitemap, OG images
pnpm --filter web serve:ssr # the built Express server on http://localhost:4000
pnpm --filter web a11y # axe (WCAG 2.1 AA, light and dark) on the built site
pnpm --filter web e2e # Playwright: journeys and accessibility, on the built siteThe two checks need the build and, once, pnpm --filter web exec playwright install chromium.
CONTRIBUTING.md has the environment variables and the conventions.
Workspace packages are consumed from source — no build step while developing. Each package
exports its TypeScript under a source condition and its dist/ for everyone else:
Three places have to agree on that condition, and each one covers a different tool:
| Where | Covers |
|---|---|
tsconfig → customConditions: ["source"] |
tsc, the IDE (go-to-definition lands in packages/*/src), Vitest |
angular.json build → conditions: [...] |
ng build (esbuild bundles everything with those conditions) |
angular.json serve → prebundle.exclude |
ng serve: the dev server hands dependencies to Vite, which does not know the condition; excluding the workspace packages makes esbuild bundle them from source instead, and edits under packages/ rebuild the running app |
Two rules follow. Every workspace package the app imports is listed in prebundle.exclude; one
missing is served from its stale dist/ by ng serve. And a package consumed from source must not
pull in a runtime dependency that apps/web does not also declare: the dev server resolves externals
from apps/web, where pnpm does not expose a package's own dependencies, and every page answers a
500 ("Cannot find module"). Data packages are dependency-free by design; shared helpers live in
@openng/core-angular-versions. The one exception is semver in @openng/data-libraries (npm's
range logic, for the registry parsing), which apps/web/package.json declares too. dist/ (tsup)
only matters for publishing to npm.
The API does the work, the UI renders (the RSC replacement). Each area has a server folder
(apps/web/src/server/<area>/: caniuse, community, libraries, releases) and a contract of types
(apps/web/src/app/features/<area>/<area>.model.ts); src/server/api.ts routes /api/<area>/… to
them, and the UI reads them with Angular's httpResource (resolvers use HttpClient), on URLs
built by apiUrl() (app/core/api/api.utils.ts). The app itself is split into core/ (layout,
API plumbing, search, theme, SEO), shared/ (presentational components, directives, utils) and
features/<area>/ (pages, components, the area's model and its route resolvers), following the
Angular folder structure guide.
Can I Use: the data packages (≈1 MB of JSON) never reach the browser bundle. apps/web/src/server/caniuse/ turns them into UI-ready views:
matrix cells per major, latest status, history, labelled links, the NG Update tree, diff rows. It
also does all searching, filtering, paging and counting. The contract (types only) is
apps/web/src/app/features/caniuse/caniuse.model.ts.
Endpoint (/api/caniuse/…) |
Used by |
|---|---|
summary |
/caniuse badges (totals) and package filter options |
counts?search= |
tab badges while a search is active |
features?search=&package=&status=&page= |
the features matrix, 20 rows per page, fetched as you scroll |
migrations?search= |
the NG Update tree (which versions start open included) |
migrations/major/<N> |
/caniuse/update/<N> |
migrations/<repo>/<name> |
/caniuse/update/migrations/<repo>/<name> |
mcp?search=, eslint?search=&type= |
the MCP and ESLint tabs |
handle.tsis the area's routing table:src/server.tsserves it over HTTP, and during SSR/prerenderServerApiBackend(app/core/api/api-backend.server.ts, the server'sHttpBackend) answers/apirequests in-process, no HTTP round trip. Being the backend, it ends the interceptor chain after Angular's HTTP transfer cache, which records every response: hydration reads them back and makes zero API requests. Angular's server platform makes relative URLs absolute before they reach a backend, so it recognises/apion the page's own origin too.- Pages declare their data as
httpResource<View>(() => apiUrl('area/view', query)):apiUrlsorts the parameters and leaves defaults out (empty values,page=1), so a view has one URL, one HTTP cache entry and one transfer-cache entry. Returningundefinedkeeps a resource idle (a search shorter than two letters). "Load more" pages come frompagedResourcewith the one-offinjectApiGet(); resolvers turn a 404 intonullwithnotFoundAsNull(). Tabs fetch their own view, keyed on the debounced search in the URL. - Search and filters need the Node server at runtime; prerendered pages still load without it.
/apianswers the web app only: requests must be same-origin and carryX-Hub-Client: web(added byapiInterceptor); anything else gets a 403, and responses areprivateso no CDN shares them. To try an endpoint by hand:curl -H 'X-Hub-Client: web' localhost:4000/api/releases/timeline. The feeds (/calendar/*.ics,/feed.xml) stay public.- Each tab is a route (
/caniuse,/caniuse/update,/caniuse/mcp,/caniuse/eslint) with its own title and canonical URL; the search and filters are query parameters shared by all four. The panels are wrapped in<ng-template #content>: Optimus'lazytabs still instantiate projected content, and a plain@ifwould fetch every tab's view up front. apps/web/src/app/core/utils/query-params.utils.tsholds the mechanics every list page shares: URL-backed filters (injectQueryParams), the debounced search box, the "latest value" of a resource (kept while the next page loads or a load fails) and "load more" paging (pagedResource). The loading, empty and error states are thehub-loading,hub-empty-stateandhub-load-errorcomponents inapps/web/src/app/shared/components/.apps/web/src/app/shared/utils/status.utils.tsis the only status logic left in the UI: icons, colours, legend and tooltip copy.
Community (/api/community/…): events?when=&type=&format=&search=&page= (upcoming soonest
first, past newest first and paged, grouped by month with every label ready),
events/map?when=&type=&format=&search= (one marker per city on a 1° pixel world map, with the
zoom regions; coordinates live in packages/data-community/data/places.json, the land outline in
apps/web/src/app/features/community/components/world-land.ts, generated by apps/web/scripts/world-map.py),
communities?country=&search= (groups meeting soon first, with their next event), podcasts, and
contribute (what the contribution form checks against). "Upcoming" depends on today's date, so
/events and /communities render per request instead of being prerendered.
Release insights (/api/releases/…): <major> (summary: sections with counts, links),
<major>/features?status=, <major>/guide?criticality=&difficulty=&impact=, <major>/update,
<major>/commits?search=&type=&package=&version=&page= (50 per page), <major>/mcp,
<major>/eslint, <major>/changelogs?channel=. Feature stage changes, NG Update, MCP and ESLint
are views of the Can I Use data; commits (data/commits.json, ~1.2 MB, stable releases only) and
GitHub releases come from the release notes on GitHub (see Generated datasets) and never reach the
browser. Every /releases/<major>/<section> page is prerendered, except the migration guide,
hidden for now and rendered on request.
Library health (/api/libraries?search=&category=&major=&sort=&page=, 24 per page, and
/api/libraries/<name>): the libraries of packages/data-libraries/data/libraries.json with the
facts of health.json and the score computed from them, for the latest major in the list and for
every major on a library's page. A deprecated or archived library gets no score (an empty grey
badge) and sorts last. /libraries/<name> pages are prerendered, one Open Graph image each, with the
score in the title. The score is experimental: both pages say so, and the rules are in
packages/data-libraries/HEALTH_SCORE.md and on /libraries/score.
/libraries/check?package= (API: /api/libraries/check?package=<npm URL or name>) scores any npm
package live (src/server/libraries/check.ts): the registry document, the advisories of the
recommended versions, the weekly downloads and the repository's archived flag are read on request
with the same rules as the sync (registryFacts, affectedVersions and healthScore from
data-libraries). A source that does not answer leaves its rule out of the score and is named in
caveats. Results are kept in memory for an hour, per server instance. GitHub's anonymous limit (60
requests an hour per IP) is shared by every visitor's check, so the server should run with
GITHUB_TOKEN set: serve:ssr reads the root .env; in production, set it in the environment.
Search (/api/search?q=): one index over every dataset and the hub's own pages, built once
(events per day, since "upcoming" moves), accent- and case-insensitive, every word required. It
answers results grouped by kind (features, migrations, MCP, ESLint, libraries, releases, events,
communities, podcasts, pages), five per group with a "See all" link to the filtered list, each saying where it
lives and linking there. The palette (apps/web/src/app/core/search/) opens from the header button,
Ctrl/⌘ K or /, and is loaded on first use.
Release timeline (/api/releases/timeline): every major placed on one axis (release dates and
active/LTS windows from ANGULAR_RELEASES in packages/core-angular-versions/src/support.ts, end
dates copied from angular.dev/reference/releases; update
it with each major). hub-release-timeline (app/features/releases/components/) loads it itself,
so any page can show it; the home page does. Support statuses depend on today, so / renders per
request too.
Rendering. app.routes.server.ts prerenders every data-driven route at build time
(getPrerenderParams lists the migration, library and release pages from the server views);
unknown URLs render on the server with a 404. A data change is a PR, a merge is a rebuild.
UI. Optimus UI only (@openng/optimus-ui, @openng/icons) plus Tailwind v4 with the
@openng/optimus-ui-tailwindcss plugin. apps/web/src/app/core/theme/aura-preset.ts composes the Aura preset from
the per-component entries of the components the app actually imports — the full preset ships the
tokens of ~90 components; add an entry there when you import a new one. The same file sets the
primary palette to the magenta of the logo (#bf25b9), so buttons, links, badges and focus rings follow
the brand. Tables are plain <table>s:
the status matrix is one DOM that turns into cards below 1300px (.hub-matrix in
styles/caniuse.css), with a single delegated tooltip for all cells. The status palette lives in
styles.css as Tailwind theme tokens built on Optimus primitives, so it follows the preset and dark
mode; the rest of the CSS is one partial per area under src/styles/, imported from styles.css in
cascade order.
Light and dark. Dark mode is the .hub-dark class on <html>: an inline script in
index.html sets it before the first paint from the visitor's choice (the header toggle, saved in
localStorage) or, without one, the OS setting. Tailwind's dark: variant (@custom-variant in
styles.css), Optimus (darkModeSelector) and the hub's own rules (.hub-dark { … }) all follow it.
CI runs the accessibility checks (apps/web/e2e/a11y.spec.ts) in both themes, so a contrast
regression fails the build.
Search and sharing. Pages set their title, description, canonical URL, Open Graph/Twitter tags
and JSON-LD through app/core/services/seo.ts (pageSeo()); the JSON-LD comes from the API (server/seo.ts:
schema.org Events on /events, TechArticle on feature and release pages, WebSite on home).
pnpm --filter web build runs scripts/postbuild.mjs after ng build: sitemap.xml and
robots.txt from the prerender list, and a pixel-style 1200×630 image per page kind, release and
tracked library in og/ (resvg, fonts in scripts/og/).
Feeds. /calendar/events.ics (every event of the last 90 days and to come), one calendar per
community (/calendar/<id>.ics, linked from its card) and /feed.xml (RSS: upcoming events and open
calls for papers), served by src/server.ts.
The datasets that follow Angular itself are read from angular/angular and angular/angular-cli rather than written by hand, so a new Angular version reaches the whole site without a code change; the libraries' health data is read from npm and the GitHub Advisory Database the same way:
| Step | Dataset | Source |
|---|---|---|
versions |
core-angular-versions/data/majors.json, compatibility.json |
angular.dev's releases and versions pages, x.0.0 releases |
versions |
data-releases/data/releases.json (new majors only) |
A new major gets its Release insights entry |
releases |
data-releases/data/github-releases.json, commits.json |
GitHub releases since v14 and the commit tables of their notes |
apis |
data-caniuse/data/api-deprecations.json |
The public API goldens of every minor since v13 |
migrations |
data-caniuse/data/angular-migrations.json |
The ng update collections of every minor |
libraries |
data-libraries/data/health.json |
npm (versions, peers, downloads) and GitHub (advisories, archived) for each tracked library |
cp .env.example .env # then set GITHUB_TOKEN (no scope needed)
pnpm data:sync # every step, in the order above
pnpm data:sync versions releases # or some of themEvery list of Angular versions in the code derives from majors.json (ANGULAR_VERSIONS,
LATEST_MAJOR, ANGULAR_RELEASES in @openng/core-angular-versions): never hard-code one.
A file is rewritten only when its content changes. Content at a tag is fetched once and cached in
packages/data-sync/node_modules/.cache; lists are revalidated with their ETag, so a re-run costs a
handful of requests. The Data sync workflow runs it every Monday and opens a pull request with the
changes, which CI and the dataset tests check like any other.
The site deploys as one Vercel project with Root Directory apps/web; apps/web/vercel.json
holds the rest:
- the build runs from the monorepo root (
pnpm turbo run build --filter=web), so the workspace packages build first; dist/web/browser(assets and the prerendered pages) is served by Vercel's CDN;- every other request is rewritten to the
api/index.mjsfunction, which loads the Express app fromdist/web/server/server.mjs(includeFiles): the API (/api/...) and server-side rendering (/events,/communities, filters, 404s); GITHUB_TOKEN(any token, no scope) goes in the project's environment variables, for the live package check.
angular.json lists the hosts SSR accepts (security.allowedHosts): hub.openng.org,
*.openng.org and *.vercel.app for preview deployments. Add any other domain there.
Data, from the site: /contribute (the "Add your event / community / podcast" buttons) builds
the entry, checks it with the dataset's own rules (@openng/data-community/validate, the code the
tests and the merge script use too) and opens GitHub's new-file page with
packages/data-community/data/inbox/<file>.json filled in: committing it there proposes the pull
request, fork included. CI validates inbox files; before merging, a maintainer runs
pnpm --filter @openng/data-community merge-inbox on the branch, which moves them into
events.json, organizers.json, podcasts.json (and places.json for a new city).
Data by hand, and code: every dataset has a vitest suite that validates it, so a broken entry
fails CI before it reaches the site. Where each file lives, the rules, the conventions and the pull
request checklist are in CONTRIBUTING.md.
Code: MIT. Data (packages/*/data, the curated lists): CC BY 4.0.
Logos belong to their owners; fonts are under the SIL Open Font License; see
ATTRIBUTION.md.