Skip to content
openng-orgPublic

About

No description, website, or topics provided.

Resources

Code of conduct

Contributing

Security policy

Stars

6 stars

Watchers

1 watching

Forks

Angular Hub

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.

Layout

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.

Running it locally

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 site

The two checks need the build and, once, pnpm --filter web exec playwright install chromium. CONTRIBUTING.md has the environment variables and the conventions.

How the pieces fit

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:

"exports": { ".": { "source": "./src/index.ts", "types": "./dist/index.d.ts", "default": "./dist/index.js" } }

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.ts is the area's routing table: src/server.ts serves it over HTTP, and during SSR/prerender ServerApiBackend (app/core/api/api-backend.server.ts, the server's HttpBackend) answers /api requests 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 /api on the page's own origin too.
  • Pages declare their data as httpResource<View>(() => apiUrl('area/view', query)): apiUrl sorts 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. Returning undefined keeps a resource idle (a search shorter than two letters). "Load more" pages come from pagedResource with the one-off injectApiGet(); resolvers turn a 404 into null with notFoundAsNull(). 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.
  • /api answers the web app only: requests must be same-origin and carry X-Hub-Client: web (added by apiInterceptor); anything else gets a 403, and responses are private so 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' lazy tabs still instantiate projected content, and a plain @if would fetch every tab's view up front.
  • apps/web/src/app/core/utils/query-params.utils.ts holds 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 the hub-loading, hub-empty-state and hub-load-error components in apps/web/src/app/shared/components/.
  • apps/web/src/app/shared/utils/status.utils.ts is 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.

Generated datasets

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 them

Every 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.

Deploying (Vercel)

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.mjs function, which loads the Express app from dist/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.

Contributing

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.

Licence

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.

About

No description, website, or topics provided.

Resources

Code of conduct

Contributing

Security policy

Stars

6 stars

Watchers

1 watching

Forks

Releases

Packages

Contributors

Languages