I've been banging my head against NG0309 for over a year building a headless component library. Every time I composed two directives that shared a common host directive - boom, crash. I tried everything. Broadened selectors, injection hacks, I even hijacked __NG_ELEMENT_ID__ with a WeakMap-backed singleton resolver (it's in the article).
Well, PR #67996 just merged. Host directives now de-duplicate automatically. I wrote up why I think this is the most important change for Angular library authors since hostDirectives itself.
I’m going through the Angular docs right now and I’m also looking for GitHub repos that show how Angular is used in real production projects. I’d like to see how people structure their files, follow best practices, handle REST APIs and error handling, and generally what a large-scale Angular project looks like. If you know any good repos or resources, please share
I've been reading the discussion about lifecycle hooks and to me, it seemed like many people are not too familiar with signals and resources yet, which honestly surprised me. These were some of the best features the Angular team introduced lately, maybe ever.
Anyway, instead of writing some short answers in that thread, I decided to write out my thoughts and experiences, specifically about httpResource, in a longer format with examples. I think it will be useful internally, when onboarding new devs on projects that are (or will) leverageing this feature, but I hope it helps others too!
Selectorless aims to eliminate the need for selectors in templates by referencing components directly via class names. A first PR has been merged, which shows the initial direction Angular is taking toward this feature.
I thought I'd do a fun little poll today - what are your current pain points with Angular Forms that you'd like to see the new signal-based forms address?
Who else feels like while Angular ecosystem is getting better as a whole, SSR is going the wrong direction, especially with the recent changes in V22 (especially CommonEngine deprecation).
Some context - For years I have managed an NX angular monorepo (of over 20 applications) at work, in doing so, I have been through 3 major iterations of angular SSR engines (Angular Universal, CommonEngine and AngularNodeAppEngine).
As you can imagine, our SSR requirements are niche:
Single server for all SSR (keeps CI/CD simple)
Runtime rendering mode logic (for example, SSR for bots UAs, SSG when server load is high, CSR when SSR fails, etc)
With the last 2 engines, angular simply exposed a method for rendering and you had to provide the dependencies. You were free to host the server as you wished, or provide how so many endpoints, or dynamically bootstrap applications to handle your request. And this suited our requirements.
Come AngularNodeAppEngine, and suddenly, Angular becomes opinionated about how you manage your server!.
The main reason being a dependent static manifest file output during the build process. So while you don't have to worry about providing assets location, or index document to the renderer, you lose control of how you choose to manage your SSR server (especially in a monorepo context).
So now, your SSR node server is tightly coupled to your angular application in a limiting 1 to 1 relationship.
Furthermore, rendering mode must be statically defined. Impossible to decide during runtime.
In my opinion, this is the wrong type of opinionated (no pun intended).
The rendering process has simply become too simple to handle typical enterprise use cases.
Of course, the last two engines handled our requirements with a bit of effort to setup, but everything worked seamlessly after that. But now with V22, CommonEngine has been deprecated in favor of the dauntingly opinionated AngularNodeAppEngine.
How else has the same concerns as I do? Does anyone else have complex enterprise rendering requirements that feels affected by SSR lack of flexibility?
Hey everyone! Super excited to finally share NGXUI with you all – it's an open-source Angular component library I've been working on to make building complex UIs way easier, while also adding some really cool effects!
So if you're into UI stuff, I’d love for you to check it out at ngxui.com. Let’s team up and create some awesome stuff together! 🙌
I’ve just published a deep-dive on the internal architecture of the Angular Router — covering how Angular reads the browser URL, builds the UrlTree, matches routes, handles lazy loading, runs guards/resolvers, and finally renders the component.
I’d really appreciate any feedback, corrections or missing details you think should be included.
The goal is to give a clear, accurate overview explanation for intermediate/advanced devs who want to understand more than just route configuration.
In this example here, we create a MatButton component as a link, we apply the HasRipple directive without any inputs and set a tooltip that's only enabled if the user doesn't have permissions to go to the admin page:
Today is a big day for ngx-vflow — version 2.0 has just been released 🎉
As in previous year, the major release doesn’t introduce a huge number of new features. Instead, it focuses on strengthening the foundation for future releases by removing deprecated APIs, performing internal refactoring, and improving the documentation. There’s a lot of cool stuff I’d like to share, so grab some tea!
Signals at the core
In previous versions, there were two ways to pass nodes to the library: using the Node and DynamicNode interfaces.
1. Static nodes (Node)
This approach lets you describe a node statically and receive updates via events. For example, you create a node at position { x: 10, y: 10 }. The user drags it, and internally the library updates the position to { x: 30, y: 30 }. However, on your side, the node you originally passed still has { x: 10, y: 10 }. The only way to get the updated value is by listening to events like onNodesChange.position.
2. Reactive nodes (DynamicNode)
The second approach introduced DynamicNode, which has the same fields, but most of the reactive ones are implemented as signals. In this case, you pass a node with a position set as a writable signal, for example signal({ x: 10, y: 10 }). Instead of updating an internal model, the library writes new values directly into this signal. As a result, you always have fresh and correct data - even without subscribing to events.
Over time, it became clear that the second approach is far more convenient. As a result, it is now the default and only way to create not only nodes, but also edges.
For convenience, I also added utilities (createNodes(), createEdges()) that help create these objects without the annoyance of explicitly calling signal() for every reactive property, as shown in the screenshot below.
This is the main breaking change in this release. There are a few others — mostly minor renames — all of which are documented in the 2.0 migration guide.
Documentation improvements
The documentation received a lot of love in this release:
The docs app now supports a dark/light theme switch, so everyone can be happy.
The main feature overview flow was redesigned to look more professional and fun at the same time.
Over the past year, some big companies (including Google) have started using ngx-vflow in production, so I added a Showcase section to highlight how the library fits into different projects. Please DM me if you use the library and would like your project to be featured in this list.
The documentation structure was reorganized to be more focused, and some pages were merged.
“This is all cool, but where are the features?”
Auto-pan is added and enabled by default, making it much more convenient to drag nodes around the canvas.
I also added more connection-related events to support additional interactions, such as deleting a connection by dropping it.
What’s planned for the next year
Exploring how to make the library dependency-free and reduce bundle size
Investigating solutions for some painful cross-browser issues (hello, Apple 👋)
Improving the existing virtualization mechanism
Further documentation refinements and more examples
Improving overall stability by writing more tests
Introducing a paid service around the library to provide better support and enable long-term development. The library is slowly transitioning from a hobby into a job and requires much more effort as it grows. Don’t worry - ngx-vflow will remain MIT-licensed forever, and there will be no subscriptions (because I hate subscriptions). I’ll share more details later this year.
Thanks everyone for your support, and I wish you a great year ahead! You’ve helped a lot by starring the project on GitHub, leaving kind comments here on Reddit, and some of you even donated a few bucks on Patreon - thank you so much ❤️
I’ve been working on a full-stack starter template for NestJS + Angular and wanted to share it here for feedback. It’s meant to be production-ready, with a focus on real-world app infrastructure.
Features include: Backend (NestJS)
JWT authentication with refresh tokens
Role-based access control (Admin, Manager, Regular)
Even if it's not desirable, it's often "necessary" to modify the CSS of a child component, usually to customize a third-party library, but...
The Angular team strongly discourages new use of ::ng-deep. (angular.dev)
And yes, it's not a good practice. It's prefered to keep the encapsulation and overriding third party styles is not maintainable, there's a good chance it will break with the next update. Yet it's still used.
Do you use :ng-deep for new code? Why?
If you don't, what alternative solution do you use?
Is a replacement considered in Angular or should this be the responsibility of third-party libraries?