Supported in TypeScript
This page lists the TypeScript libraries, frameworks and build tools Niro was tested against, and whether it recognised each one.
What the marks mean.
- Supported: Niro recognised every way of using it that the test code tries.
- Partly: Niro recognised some of those ways, or recognised one only in part.
- Not yet: Niro did not recognise it in the test code.
The test code is made up for the purpose: one small service per library, with the names invented. So "supported" means Niro recognised it there. It is good evidence, but it is not a promise about every codebase. If Niro misses something in your code, the coverage audit reports the gap on its own (see Coverage audit).
The test catalog also holds 19 look-alike cases for TypeScript: code that Niro must NOT take for a route, a call or a store. They test that Niro ignores the look-alike, so they are left out of this page and its counts.
Web frameworks and HTTP servers (the routes your code serves)
45 supported, 3 partly, 4 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| @adonisjs/core | partly | yes: router.get(path, handler) in start/routes.ts no: router.resource('podcasts', Controller).only([...]) yes: router.group(() => {...}).prefix('/admin') |
| @analogjs/platform | supported | yes: src/server/routes/api/<path>.<verb>.ts: Analog API routes (Nitro), verb from the file name yes: src/server/routes/api/<path>/[param].ts: a dynamic Analog API route, every verb |
| @angular/router | supported | yes: Routes array { path: 'quotes/:id', component }: client-side routes, NOT endpoints |
| @azure/functions (v3 programming model) | supported | yes: <FunctionName>/function.json with an httpTrigger binding: route (with {param}, {param:constraint}, {param?}) and methods, under host.json routePrefix (default api) yes: function.json httpTrigger with no route: /api/<FunctionName>, the folder name |
| @azure/functions (v4) | supported | yes: app.http('name', { methods, route, handler }); served under /api yes: app.get / app.post / app.put / app.patch / app.deleteRequest(name, handler or options): the verb is the call, the route is options.route or the name |
| @builder.io/qwik-city | supported | yes: src/routes/<path>/index.ts exporting onGet, onPost, ...: a Qwik City endpoint (only index files are routes) yes: src/routes/<path>/[param]/index.ts: a dynamic Qwik City endpoint yes: index.ts exporting onRequest: one handler for every method, here under a [...rest] folder yes: src/routes/(group)/<path>/index.ts: a grouped folder is left out of the URL |
| @fastify/autoload | supported | yes: register(AutoLoad, { dir: 'routes' }): each folder's name prefixes the routes its plugin registers (dirNameRoutePrefix default true) yes: routeParams: true: a folder named _param becomes :param in the prefix yes: options: { prefix } on the AutoLoad registration, plus export const autoPrefix in the plugin file |
| @loopback/rest | not yet | no: lower-case @get('/x/{id}') and @post('/x') on methods |
| @nestjs/common | partly | yes: @Controller('prefix') class with @Get(), @Get(':id'), @Post() yes: @Put(path), @Patch(path), @Delete(path) with stacked decorators partly: app.setGlobalPrefix('api') in main.ts applies to every controller partly: @Controller({ path, version }) with URI versioning |
| @oak/oak (Deno) | supported | yes: new Router().get().post() imported from jsr:@oak/oak |
| @react-router/dev (React Router v7 framework mode) | supported | yes: app/routes.ts config: route('api/stock/:sku', './api/stock.ts') and prefix('v2', [...]) name the path and the module |
| @react-router/fs-routes (React Router v7 framework mode) | supported | yes: app/routes.ts export default flatRoutes() and app/routes/<dotted>.ts resource routes (loader GET, action POST/PUT/PATCH/DELETE) |
| @remix-run/node | supported | yes: app/routes/<dotted.path>.tsx exporting loader (GET) and action (POST) |
| @remix-run/node (Remix v2) | supported | yes: a resource route: a route module with a loader and no default component, serving GET only yes: <parent>._index.ts: the index route of a parent path yes: <path>.$.ts: a splat route, params['*'] holds the rest of the URL yes: layout.<path>.ts: a leading underscore segment is a pathless layout, left out of the URL yes: <segment>.<rest>.ts: a trailing underscore opts out of the parent layout; the underscore is not in the URL yes: ($param).<path>.ts: an optional segment, matching with and without it yes: [.] or [.ext] in a file name keeps a literal dot in the URL yes: <path>/route.ts: a folder route; other modules in the folder are not routes |
| @solidjs/start | supported | yes: src/routes/<path>.ts exporting GET, POST, ... (no default component): a SolidStart API route yes: src/routes/<path>/[param].ts: a dynamic SolidStart API route yes: src/routes/<path>/[...rest].ts: a catch-all SolidStart API route, verb bound by export const GET = handleryes: src/routes/(group)/<path>/[[optional]].ts: a group folder and an optional parameter; one function bound to two verbs |
| @sveltejs/kit | supported | yes: src/routes/<path>/+server.ts exporting GET/POST/DELETE (const or function) yes: src/routes/<path>/[param]/+server.ts: a dynamic segment yes: src/routes/<path>/[...rest]/+server.ts: a rest parameter, which may match zero segments yes: src/routes/<path>/[[optional]]/...: an optional parameter in the middle of the path yes: src/routes/(group)/<path>/+server.ts: a group folder is left out of the URL yes: src/routes/<path>/[id=matcher]/+server.ts: a parameter with a matcher from src/params yes: +server.ts exporting fallback: serves every method with no handler of its ownyes: +page.server.ts export const actions: form actions answer POST at the page's path (default) or ?/nameyes: +server.ts beside +page.svelte in one folder (content negotiation): GET with Accept text/html goes to the page, others to +server |
| @tanstack/react-start | supported | yes: src/routes/<path>.ts: createFileRoute('/path')({ server: { handlers: { GET, POST } } }); a file may also hold a component yes: src/routes/<path>/$param.ts, $.ts splat and [.] escape in a server route |
| @tanstack/start (before the Vite move) | supported | yes: app/routes/api/<path>.ts: export const APIRoute = createAPIFileRoute('/api/path')({ GET, POST }) |
| @trpc/server | not yet | no: t.router({ ns: t.router({ q: procedure.query(), m: procedure.mutation() }) }): GET /trpc/ns.q, POST /trpc/ns.m |
| astro | supported | yes: src/pages/<path>.ts exporting GET/POST APIRoute yes: src/pages/<path>/[param].ts in server output: a dynamic endpoint; _file and _folder are excluded yes: src/pages/<path>/[...path].ts: a rest parameter, which also matches the bare path yes: src/pages/<name>.<ext>.ts: the output extension stays in the URL (feed.json.ts -> /feed.json), also after a parameter |
| AWS SAM template.yaml | supported | yes: Events: Type: HttpApi Properties: Path, Method; Handler names the export |
| aws-lambda (API Gateway v2) | not yet | no: switch (event.routeKey) { case 'GET /claims': ... } |
| bun (Bun.FileSystemRouter) | supported | yes: new Bun.FileSystemRouter({ style: 'nextjs', dir }) with router.match(req) in Bun.serve: Next.js-style file names under dir, no method chosen |
| Cloudflare Pages Functions | supported | yes: functions/<path>.ts exporting onRequest: every verb at the file's path yes: exports onRequestGet, onRequestPost, onRequestPut, onRequestPatch, onRequestDelete, onRequestHead, onRequestOptions: the export name is the verb yes: functions/index.ts serves / and functions/<dir>/index.ts serves /<dir> yes: functions/<dir>/[param].ts: one segment, value in context.params yes: functions/<dir>/[[param]].ts: matches any depth, params.param is an array yes: _routes.json in the build output folder: exclude wins over include, an excluded path never reaches a function |
| elysia | partly | yes: new Elysia().get().post() chained no: app.group('/prefix', app => app.get(...)) |
| elysia-autoload | supported | yes: app.use(await autoload({ dir, prefix })): routes/<path>.ts default-exports (app) => app.get('', ...); [id].ts and [...].ts |
| Expo Router API routes (expo-router) | supported | yes: app/<path>+api.ts exporting GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS with web Request and Response yes: app/<dir>/[param]+api.ts: one segment, passed as the second argument yes: a (group) folder adds nothing to the URL yes: app/<dir>/[...rest]+api.ts: catch-all |
| express | supported | yes: typed Router (Request<Params>, Response) mounted with app.use("/api", router) |
| express-file-routing | supported | yes: routes/<path>.ts exporting get, post, put, patch, del; mounted with app.use('/api', await router()) yes: a default export serves every method; [...path].ts is a catch-all (not the base path alone) |
| fastify | supported | yes: Fastify().withTypeProvider<T>().get(path, { schema }, h); fastify.post<{ Body }>(path, h) |
| fresh (deno.land/x/fresh, Fresh 1) | supported | yes: routes/<path>.ts: export const handler: Handlers = { GET, POST } |
| fresh (jsr:@fresh/core, Fresh 2) | supported | yes: routes/<path>.ts: export const handler = define.handlers({ GET, POST, ... }) yes: define.handlers((ctx) => ...): one function serves every method yes: [...path] catch-all, [[optional]] parameter and (group) folder in Fresh routes |
| Gatsby Functions (gatsby) | supported | yes: src/api/<path>.ts default export handler(req, res): /api/<path>, every verb yes: src/api/<dir>/index.ts: /api/<dir> yes: src/api/<dir>/[param].ts: one segment, value in req.params yes: src/api/<dir>/[...].ts (or [...name].ts): matches everything after the splat |
| h3 | supported | yes: createRouter().get(path, defineEventHandler(...)) |
| hono | supported | yes: app.get/app.post(path, handler) yes: app.route('/prefix', subApp) yes: new Hono().basePath('/api').get(path) |
| honox | supported | yes: app/routes/<path>.ts: export default createRoute(...) serves GET yes: app/routes/<path>.ts: export const POST = createRoute(...) and the other verbs |
| inversify-express-utils | not yet | no: @controller('/x') with @httpGet, @httpPost, @httpDelete |
| Netlify Edge Functions (@netlify/edge-functions) | supported | yes: netlify/edge-functions/<name>.ts default export with export const config = { path } |
| Netlify Functions (@netlify/functions) | supported | yes: netlify/functions/<name>.mts default export (req, context) with no config.path: /.netlify/functions/<name> yes: export const config: Config = { path: '/x/:id', method: [...] }: the path replaces /.netlify/functions/<name> yes: config.path as an array, with * wildcards and :named groups yes: netlify/functions/<name>/index.mts or <name>/<name>.mts is function <name>; other files in the folder are helpers |
| Netlify Functions (@netlify/functions), Lambda-compatible | supported | yes: netlify/functions/<name>.ts exporting handler(event, context): served at /.netlify/functions/<name>, every verb |
| netlify.toml | supported | yes: [functions] directory = '<dir>': functions are read from that folder instead of netlify/functions yes: [[redirects]] from = '/x/' to = '/.netlify/functions/<name>' status = 200: a rewrite to a function yes: [[edge_functions]] path = '/x/' function = '<name>': routes an edge function from config |
| next | supported | yes: app/<path>/[[...slug]]/route.ts: optional catch-all segment, also matches the bare folder path yes: app/<path>/[...slug]/route.ts: catch-all segment in the app router yes: app/(group)/<path>/route.ts: a route group folder is left out of the URL yes: app/<path>/_folder/...: a private folder opts out of routing; %5Ffolder is the escape that keeps a literal underscore yes: a route.ts handler in a child segment of a page, outside app/api; page.tsx, layout.tsx and proxy.ts are not endpoints yes: route.ts with export const runtime = 'edge': an edge route handleryes: a folder whose name holds a dot, app/rss.xml/route.ts, serves /rss.xml yes: metadata route files app/sitemap.ts and app/robots.ts are special route handlers serving /sitemap.xml and /robots.txt yes: src/app/<path>/route.ts: the app router placed under src/ yes: src/pages/api/<name>.ts: the pages router API placed under src/ yes: pages/api/<path>/[...slug].ts: catch-all API route, as NextAuth's pages/api/auth/[...nextauth].ts yes: pages/api/<path>/[[...slug]].ts: optional catch-all API route, also matches the bare path yes: app/ at the root and src/app both present: src/app is ignored |
| next (app router) | supported | yes: app/api/<path>/route.ts exporting GET/POST functions yes: app/api/products/[id]/route.ts dynamic segment |
| next (pages router) | supported | yes: pages/api/<name>.ts typed NextApiRequest handler |
| nitropack (standalone Nitro) | supported | yes: a standalone Nitro app: routes/<path>.ts under srcDir (server/ here), verb from the file name yes: a standalone Nitro app: api/<path>.ts served under /api |
| nuxt (nitro) | supported | yes: server/api/<name>.<verb>.ts default defineEventHandler: path and verb from the file name yes: server/routes/<name>.ts: any verb, no /api prefix yes: server/api/<path>/[id].get.ts: a dynamic segment with a verb in the file name; also two parameters in two folders yes: server/api/<path>/index.post.ts: an index file with a verb serves the folder's own path yes: server/api/<path>/[...slug].ts: a named catch-all, which also matches the base path yes: server/api/<path>/[...].ts: an unnamed catch-all (params._) |
| RedwoodJS functions (@redwoodjs/api) | supported | yes: api/src/functions/<name>.ts exporting handler(event, context): served at /<name> yes: api/src/functions/<name>/<name>.ts or <name>/index.ts: function <name>; other files there are not exposed |
| routing-controllers | supported | yes: @JsonController('/x') with @Get('/'), @Get('/:id'), @Post('/') |
| tsoa | supported | yes: @Route('x') class extends Controller with @Get('{id}') and @Post() |
| type-graphql | supported | yes: @Resolver class with @Query/@Mutation, served by Apollo on /graphql |
| Vercel Functions (@vercel/node), no framework | supported | yes: api/<name>.ts default export handler(req: VercelRequest, res: VercelResponse): path from the file, every verb yes: api/<name>.ts exporting GET, POST, ... with web Request and Response: the export name is the verb yes: api/<name>.ts default export { fetch(request) }: one handler for every verb yes: api/index.ts serves /api and api/<dir>/index.ts serves /api/<dir> yes: api/<dir>/[param].ts: a bracketed file name is one path segment, value in req.query yes: api/<dir>/[...name].ts outside Next.js: still ONE segment, not a catch-all yes: api/<name>.ts with export const config = { runtime: 'edge' }: same path rule as Node |
| vercel.json | supported | yes: rewrites: [{ source, destination: '/api/<fn>' }]: the source path is served by that function yes: cleanUrls: true: a function is served without its extension; the extension form only redirects yes: routes: [{ src: <regex>, methods, dest: '/api/<fn>' }]: regex source, optional verbs |
The language's own HTTP server
0 supported, 0 partly, 3 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| Bun.serve | not yet | no: Bun.serve({ routes: { '/path': { GET, POST } } }) in TS |
| Deno.serve | not yet | no: Deno.serve(opts, handler) with new URL(req.url).pathname comparison |
| Deno.serve + URLPattern | not yet | no: new URLPattern({ pathname: '/x/:id' }).exec(req.url) |
HTTP client libraries (the calls your code makes to other services)
10 supported, 8 partly, 8 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| @angular/common/http | partly | no: provideHttpClient(withInterceptors([...])) in app.config.ts (standalone bootstrap) yes: class AuthInterceptor implements HttpInterceptor registered through HTTP_INTERCEPTORS (adds a header only) |
| @angular/common/http HttpClient | not yet | no: private http = inject(HttpClient) in a standalone component; this.http.put<T>(${environment.apiUrl}/path)no: functional HttpInterceptorFn that puts environment.apiUrl in front of relative URLs; services call this.http.get<T>(relative) no: NgModule app with HttpClientModule; service with constructor(private httpClient: HttpClient); get<T>( ${environment.apiUrl}/x/${id}, { params })no: constructor(private http: HttpClient); this.http.get<T>( ${environment.x}/path)no: this.http.post<T>( ${this.base}/path, body) with the base in a class fieldno: this.http.delete<T>(url with id) |
| @apollo/client | supported | yes: useQuery<T>(gql) and useMutation(gql) in a .tsx component, uri on the client in another module yes: new ApolloClient({ uri }); client.query({ query: gql ... }) |
| @builder.io/qwik-city | partly | no: export const useX = routeLoader$(async () => fetch(...)) yes: server$(async function (...) { fetch(...) }) |
| @nestjs/axios HttpService | partly | partly: this.httpService.get(url) wrapped in firstValueFrom yes: this.httpService.axiosRef.post(url, body) |
| @reduxjs/toolkit (RTK Query) | not yet | no: createApi({ baseQuery: fetchBaseQuery({ baseUrl }), endpoints: b => ({ x: b.query({ query: () => 'path' }) }) }) |
| @tanstack/react-query | supported | yes: useQuery({ queryKey, queryFn }) where queryFn calls fetch yes: useMutation({ mutationFn }) where mutationFn calls axios.post |
| @trpc/client | not yet | no: createTRPCProxyClient({ links: [httpBatchLink({ url })] }); trpc.ns.proc.query() |
| axios | partly | no: export const http: AxiosInstance = axios.create({ baseURL: import.meta.env.X ?? default }); http.get<T>(path) in another module partly: const api: AxiosInstance = axios.create({ baseURL }); api.get<T>(path) |
| ky | supported | yes: ky.get(url).json<T>() yes: ky.create({ prefixUrl }) then api.post(relative, { json }) |
| next | partly | partly: base URL from process.env.NEXT_PUBLIC_API_URL ?? default in a shared lib module |
| next (app router) | partly | partly: fetch(url, { next: { revalidate } }) in an async server component |
| next (middleware) | not yet | no: NextResponse.rewrite(new URL(path, backendOrigin)) in middleware.ts |
| next (next.config.js) | not yet | no: rewrites() returning { source, destination } that proxies to a backend no: redirects() sending the browser to a backend URL |
| next (pages router) | supported | yes: export const getServerSideProps: GetServerSideProps = async () => fetch(...) |
| next (server actions) | partly | partly: 'use server' module exporting an async action that calls fetch |
| nuxt ($fetch in .vue) | supported | yes: $fetch(url, { method }) in a .vue function |
| nuxt (useFetch in .vue) | not yet | no: const { data } = await useFetch<T>(url) in <script setup lang="ts"> |
| nuxt (useFetch in a composable) | not yet | no: useFetch(path, { baseURL }) in composables/*.ts |
| ofetch | supported | yes: ofetch(url, { method: 'DELETE' }) |
| ofetch ($fetch, Nuxt) | supported | yes: $fetch(path, { baseURL }) |
| openapi-fetch | not yet | no: createClient<paths>({ baseUrl }).GET('/path/{id}', { params }) |
| react-router-dom | supported | yes: route object loader: async ({ params }: LoaderFunctionArgs) => fetch(...) |
| solid-js | supported | yes: createResource(fetcher) where the fetcher calls fetch |
| swr | partly | partly: useSWRMutation(url, fetcher with { arg }) in .tsx yes: useSWR(url, fetcher): the key is the URL and the fetcher calls fetch(url) |
| vue (single-file component, lang ts) | supported | yes: axios.post in <script setup lang="ts"> |
The language's own HTTP client
2 supported, 1 partly, 5 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| astro (.astro page) | not yet | no: fetch in the --- frontmatter of a .astro page |
| EventSource (browser) | not yet | no: new EventSource(url) for server-sent events |
| fetch (browser) | partly | partly: fetch(${API}/path) in a function inside useEffect, base from import.meta.env ?? default |
| fetch (global) | not yet | no: async function http<T>(path, init) { fetch(${BASE}${path}, init) }; http<Fare>(/fares/${id}) |
| navigator.sendBeacon (browser) | not yet | no: navigator.sendBeacon(url, data): a POST |
| svelte (component, lang ts) | supported | yes: fetch in <script lang="ts"> of a .svelte file |
| WebSocket (browser) | supported | yes: new WebSocket('ws://host/path') |
| XMLHttpRequest (browser) | not yet | no: xhr.open('POST', url); xhr.send(body) |
gRPC
3 supported, 1 partly, 1 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| @connectrpc/connect (connect-es) | supported | yes: router.service(Desc, { method(req) {...} }) inside connectNodeAdapter({ routes }) yes: createClient(Desc, createConnectTransport({ baseUrl })); client.method(req) |
| @grpc/grpc-js + ts-proto | not yet | no: server.addService(XService, impl) where impl is a typed const, not an object literal in the call no: new XClient(addr, creds) from makeGenericClientConstructor; client.method(req, cb) |
| @nestjs/microservices (gRPC transport) | supported | yes: nestjs-grpc-method: @GrpcMethod('Service', 'Method') with package and protoPath in createMicroservice options yes: @GrpcStreamMethod('Service', 'Method') with Observable in and out yes: @GrpcMethod('Service') with the RPC name taken from the method name, capitalised yes: service_lookup: client.getService<T>('Service') then svc.method(req); package and url in ClientsModule.register |
| grpc-web | supported | yes: new {S}Client(url) from *_grpc_web_pb; client.method(req, metadata, cb) yes: new {S}PromiseClient(url).method(req) |
| nice-grpc | partly | no: createServer().add(XDefinition, { method(req) {...} }) with ts-proto generic definitions partly: createClient(XDefinition, createChannel(addr)); client.method(req) |
Databases and data stores
5 supported, 3 partly, 7 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| @libsql/client | supported | yes: client.execute(sql) and client.execute({ sql, args }) |
| @mikro-orm/core | not yet | no: @Entity({ tableName }); em.find(Entity, q); em.nativeDelete(Entity, q) |
| @neondatabase/serverless | not yet | no: const sql = neon(url); await sqlSELECT ... |
| @nestjs/mongoose | not yet | no: @Schema({ collection }) class; @InjectModel(X.name) private model: Model<X>; this.model.find() |
| @nestjs/typeorm | not yet | no: constructor(@InjectRepository(Entity) private repo: Repository<Entity>); this.repo.find() |
| @prisma/client | partly | no: prisma.<model>.findMany/create where schema.prisma maps the model with @@map("table") no: prisma.<model>.findUnique with no @@map: the table is the model name yes: prisma.$queryRaw SELECT ... tagged templateno: main reads a table another service writes, through its own Prisma schema |
| @supabase/supabase-js | partly | yes: supabase.from('table').select()/update() no: supabase.storage.from('bucket').upload() yes: main reads a table another service writes |
| @typegoose/typegoose | not yet | no: @modelOptions({ schemaOptions: { collection } }); getModelForClass(C).find() |
| @upstash/redis | supported | yes: new Redis({ url, token }).incr/get(key) |
| @vercel/postgres | supported | yes: sqlSELECT ... imported from @vercel/postgres |
| dexie | not yet | no: class X extends Dexie { t!: Table }; db.t.add(); db.t.where().equals().toArray() |
| drizzle-orm | partly | yes: pgTable('table', cols) in schema.ts; db.select().from(table) / insert(table) / delete(table) no: db.execute(sql ...) |
| kysely | supported | yes: db.selectFrom('t').selectAll().execute(); insertInto('t'); deleteFrom('t') |
| sequelize-typescript | not yet | no: @Table({ tableName }) class X extends Model; X.findAll()/create() |
| typeorm | supported | yes: @Entity('table') class; dataSource.getRepository(Entity).find()/save() yes: createQueryBuilder().select().from(Entity, 'alias').getOne() yes: dataSource.query(sql, params) |
Messaging and events (queues, topics, streams)
4 supported, 1 partly, 4 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| @azure/functions (v4) | supported | yes: app.serviceBusQueue('name', { queueName, handler }) |
| @nestjs/bullmq | not yet | no: @Processor('queue') class extends WorkerHost { process(job) } no: @InjectQueue('queue') private q: Queue; this.q.add('job', data) |
| @nestjs/event-emitter | supported | yes: this.events.emit('name') and @OnEvent('name') handler |
| @nestjs/microservices | partly | yes: @MessagePattern('pattern') request-reply handler yes: @EventPattern('pattern') event handler no: @Inject('X') private client: ClientKafka; this.client.emit('pattern', data) no: this.client.send('pattern', data) request-reply |
| @nestjs/websockets | supported | yes: @SubscribeMessage('event') on a @WebSocketGateway; this.server.emit('event') |
| AWS SAM template.yaml | not yet | no: Events: Type: SQS Properties: Queue, the handler consumes the queue |
| inngest | not yet | no: inngest.createFunction({ id }, { event: 'name' }, handler) no: inngest.send({ name, data }) |
| mitt | supported | yes: const bus = mitt<Events>(); bus.on('x', h); bus.emit('x', data) |
| socket.io-client | not yet | no: io(url).emit('event') and socket.on('event') in a React component |
Build tools and package managers
9 supported, 0 partly, 0 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| Angular CLI workspace | supported | yes: angular.json with an application and a library under projects/, ng-package.json, tsconfig paths pointing the library at dist/ |
| Deno (deno.json imports) | supported | yes: deno.json "imports" map naming a local library folder and jsr:/npm: specifiers; tasks; no package.json |
| Deno 2 workspaces | supported | yes: root deno.json "workspace": ["./api", "./money"], each member with its own deno.json name and exports |
| Nx (integrated repo) | supported | yes: nx.json, project.json per project with projectType, no package.json in apps or libs, tsconfig.base.json paths for libs |
| Nx (package-based repo) | supported | yes: npm workspaces plus nx.json; each package has package.json and a project.json with projectType |
| tsconfig paths | supported | yes: one app with "baseUrl": "." and "paths": { "@app/": ["src/"], "@lib/": ["lib/"] }, imports through the aliases |
| Turborepo | supported | yes: turbo.json tasks, apps/web (Next.js) and apps/api (fastify), packages/ui, plus config-only packages (tsconfig, eslint-config) |
| TypeScript project references | supported | yes: root tsconfig.json "references" to packages/core and packages/server, composite true, outDir lib/ per package; no workspaces |
| Vite | supported | yes: vite.config.ts resolve.alias "@" to src and "~ui" to a sibling package folder, dist/ output, plus tsconfig paths for the same "@" |
Project and folder layouts
3 supported, 0 partly, 0 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| code generators (GraphQL codegen, Relay, OpenAPI, Prisma) | supported | yes: src/gen/ with a "generated, do not edit" header, generated/ next to components, prisma client in node_modules |
| Next.js (app router) | supported | yes: src/app/ with route.ts handlers and server components, src/lib helpers, "@/*" alias, .next/ output |
| Storybook | supported | yes: .storybook/ config, *.stories.tsx next to components, storybook-static/ build output |
Deployment files
1 supported, 0 partly, 0 not yet.
| Name | Status | Ways of using it that were tested |
|---|---|---|
| docker-compose.yml at the monorepo root | supported | yes: compose services with build: ./apps/x and build: { context: ., dockerfile: apps/y/Dockerfile }, init ONCE at the repository root yes: the same repository, but each app folder added to one project with its own niro-local init (how the coverage-run monorepos were measured) |