Angular

ANGULAR NEWS: Using the Wordpress API, Developer Advocacy, PrimeNG, NgUpgrade & RxJS

Oct 28, 2019

6 min read

The Angular community is continuously rolling out new tools and resources to help increase the capacity of its members. Keep up with current Angular news as Tracy Lee (@ladyleet) and Taras Mankovski (@tarasm) discuss a variety of topics with Angular experts.

Featured in this article are interviews with Roy Sivan (@royboy789) from Walt Disney, John Papa (@John_Papa) from Microsoft, Kito Mann (@kito99) from Virtua, George Kalpakas(@gkalpakas) from the Angular core team and Ben Lesh (@benlesh) from Google.

Wordpress’ API for Mobile App Development & Content Management

The benefits of using WordPress API with Roy Sivan

Roy Sivan is a Senior WordPress developer at Walt Disney. He is a technology expert on WordPress and using WordPress in SPA and mobile development.

WordPress is still a strong contender a CMS solution. It has never been easier to decouple applications from WordPress and allow those working on site content to build out material which can then be used to create applications with any framework of choice, including Angular.

The WordPress API has recently become a popular choice for companies looking to build mobile apps. Because the WordPress API is decoupled from WordPress, you can use AppPresser to pull data from the main site and display it in a native mobile application.

If you have looked into WordPress before and been concerned about security, the open source community has been hard at work solving this problem. Security has always been an important consideration for WordPress due to the large size of the platform, but because of a recent uptick in contributions to this concern, there are now a variety of options for authentication.

Roy encourages those interested in pursuing WordPress to review the new developer handbook to better understand the variety of customization possibilities. It serves as a great resource with in-depth tutorials that walk you through everything from advanced customizations to building your own API endpoints. Chances are, whatever you are trying to accomplish with WordPress has already been thought out and is in the documentation.

{% youtube uWnTyg4pfSA %}

The Life of a Developer Advocate and How to be a Better Developer

Using advocacy to propel development in the community with John Papa

Working as a Developer Advocate is all about sharing experience and showing people new ways of doing things. John Papa has been coding for most of his life and a developer advocate for the past 10 years. He loves making contributions that make code easier so developers can focus on the real problems.

John Papa’s work as an advocate includes a variety of methods to promote development in the community.

In Angular, John’s work has played a key role in developer’s lives. He recently wrote VS Code snippets for Angular to help make writing Angular code easier. His snippets allow Angular developers to get rid of much boiler plate and add consistency to their code.

John also played an integral part in creating the style guide for Angular and AngularJS. His style guide work for Angular played significantly into the opinions Angular-CLI gives developers.

John is always encouraging people to get more involved in their development communities. He recommends getting on social media and engaging in conversations, contributing to open source projects, building extension tools, and finding other ways to help developers in their work.

You will often find him presenting at conferences and events. He stresses the importance of participating in hallway conversations and views this as a great way to see what people are saying about different tools. By talking to people between sessions and listening to people’s concerns as a developer advocate, he is able to help give that feedback to core teams and make improvements all around.

{% youtube e0ipsapraDA %}

PrimeNG

Getting started with PrimeNG with Kito Mann

If you’ve done development in Java, you may be familiar with PrimeFaces, a popular Java component library. We sit down with Kito Mann, a technology trainer and mentor at Virtua to discuss PrimeNG.

PrimeNG is an Angular component library that is a derivative of PrimeFaces. The library offers over 70 open source native Angular components along with a variety of theming options for developers.

PrimeNG has become popular amongst developers in organizations as small as 2–3 person shops and large organizations. The primary benefit developers see when using PrimeNG is help with developing complicated UI such as grids, charts and calendar components.

{% youtube mw2G3fclPLY %}

NgUpgrade

Integrating ngUpgrade and the latest developments in Angular with George Kalpakas

Constant innovation in the Angular team has recently brought us ngUpgrade. NgUpgrade works by enabling upgrades (making AngularJS components available in Angular) and downgrades (making Angular components available in AngularJS) between components. The goal and vision of the ngUpgrade project is to make it easier for developers working with large AngularJS applications to upgrade to the latest version of Angular. To use ngUpgrade, developers simply need to add upgrade to their projects and bootstrap both frameworks using a sequence of operations.

George Kalpakas, a member of the Angular core team and core contributor to the ngUpgrade project, speaks with us about the project and the plans the Angular team has in store for developers.

There have been a significant amount of improvements to the ngUpgrade project as of late. Recently, ngUpgrade was re-written to incorporate AOT compilation. Another recent addition was improving the interoperability of things like ngModel and control access monitor in order to make it easier to use components and interpolate between Angular and AngularJS.

The path to creating ngUpgrade has not been an easy one. Some of the challenges the team has faced through this process was getting both frameworks to be aware of each other. Current challenges the team is working on is the debugging story for ngUpgrade and solving challenges around users not configuring ngUpgrade correctly and running into errors.

Looking forward, the ngUpgrade team is working on docs and other resources to help people get started using ngUpgrade. Additional plans include improving the performance of ngUpgrade apps and providing more tooling and more boiler plates for various use cases.

If users have questions or feedback through the upgrade process, you can reach George through the ngUpgrade GitHub project where the Angular team is always looking to hear more from their users.

{% youtube IIW5IxhHhVk %}

RxJS

RxJS 6 and 7, Testing, and more with Ben Lesh, Author and Project Lead of RxJS 5+

Ben Lesh is a Software Engineer at Google and is the author and project lead for RxJS 5+. He provides us with an update on the current state of RxJS. Currently, the size of RxJS (minified, bundled, and gzipped is 33k. However, Ben has created a library that shrunk the size of RxJS to only 3k!

To do this, he moved all the error handling into one central spot so v8 can inline all the other functions without having to deal with the de-optimized functions that you get if you have a tryCatch block in a function.

There were some compromises that Ben had to make in order to get it to a smaller size, but the new improvements to the library should be roughly the same speed and about 10x smaller.

Though RxJS does not currently take advantage of Angular’s compiler, an ideal scenario would be to get Angular’s template compiler and use it at build-time to produce functions able to handle updates in the DOM based on the compiled template.

Many who use RxJS wonder about RxJS’s testing story. RxJS has a great testing suite that runs a battery of more than 2,500 tests within a second. Unfortunately it does not provide much utility to the average user yet. The test suite currently schedules synchronistic tests on things that would normally run asynchronistically but does it in a determinate way. It makes some assumptions based off the fact that it is only really used in RxJS’s core library, but there is work being done to make this more useful externally. A lot of challenging problems remain to be resolved before it is successful.

New updates on the testing story include a prototyping of a testing suite in T-Rx. Ben tells us he was able to re-write the schedulers meaning that he had access to a brand new virtual scheduler that he wrapped in a high order function that gives users access to everything you might need for testing. This automatically sets up the other schedulers so they work in an expected way with the test scheduler.

{% youtube r416kcmmuek %}

There is more to come, so keep up to date with RxJS on the latest developments on the project in Github.

Co-written by Necoline Hubner and Tracy Lee.

Need JavaScript consulting, mentoring, or training help? Check out our list of services at This Dot Labs.

This Dot Labs is a development consultancy that is trusted by top industry companies, including Stripe, Xero, Wikimedia, Docusign, and Twilio. This Dot takes a hands-on approach by providing tailored development strategies to help you approach your most pressing challenges with clarity and confidence. Whether it's bridging the gap between business and technology or modernizing legacy systems, you’ll find a breadth of experience and knowledge you need. Check out how This Dot Labs can empower your tech journey.

You Don't Need NgRx To Write a Good Angular App

NgRx is a great tool that allows you to manage state and side effects in Angular applications in a Redux-like manner. It streamlines state changes with its unidirectional data flow, and offers a structured approach to handling data and side effects. Numerous posts on our blog detail its strengths and affiliated techniques. Some Angular developers even argue that incorporating NgRx is imperative once an app expands beyond two features. While NgRx can undoubtedly enhance an Angular application or library by simplifying debugging, translating business logic into code, and improving the architecture, it does present a steep learning curve. Despite the provocative title, there is some truth to the statement: your app or library may indeed not need NgRx. Surprisingly, I successfully developed a suite of enterprise Angular libraries over five years without involving NgRx. In that project, we decided to opt out of using a state management library like NgRx because of its steep learning curve. Developers with varying levels of Angular expertise were involved, and the goal was to simplify their experience. My bold assertion is that, with careful consideration of architectural patterns, it is entirely possible to develop a robust app or library using only Angular, without any third-party libraries. Employing select design patterns and leveraging Angular's built-in tools can yield a highly maintainable app, even without a dedicated state management library. Having shared my somewhat audacious opinion, let me now support it by outlining a few patterns that facilitate the development of a maintainable, stateful Angular application or library without NgRx. Services and the Singleton Pattern Services provided in root` or a module yield a shared instance across the entire app or module, effectively rendering them singletons. This characteristic makes them ideal for managing and sharing state across components without requiring a dedicated state management tool like NgRx. Particularly, for small to medium-sized applications, a "state service" can be a straightforward and effective alternative to a comprehensive state management solution when implemented correctly. To accurately implement state in a singleton service, consider the following: - Restrict state data to private properties and expose them only through public methods or observables to prevent external mutations. Such a pattern safeguards the integrity of your state by averting unauthorized modifications. - Utilize BehaviorSubjects or signals to enable components to respond to state changes. Both BehaviorSubject` and `SettableSignal` retain the current value and emit it to new subscribers immediately. Components can then subscribe to these to receive the current value and any subsequent updates. - Expose public methods in your service that manage state modifications to centralize the logic for updating the state and incorporate validation, logging, or other necessary side effects. - When modifying state, always return a new instance of the data rather than altering the original data. This ensures that references are broken and components that rely on change detection can accurately detect changes. Good Component Architecture Distinguish your UI components into stateful (containers) and stateless (presentational) components. Stateful components manage data and logic, while stateless components merely receive data via inputs and emit events without maintaining an internal state. Do not get dragged into the rabbit hole of anti-patterns such as input drilling or event bubbling while trying to make as many components presentational as possible. Instead, use a Data Service Layer to provide a clean abstraction over backend API calls and handle error management, data transformation, caching, and even state management where it makes sense. Although injecting a service into a component technically categorizes it as a "smart" component, segregating the data access logic into a separate service layer ultimately enhances modularity, maintainability, scalability, and testability. Immutability A best practice is to always treat your state as immutable. Instead of modifying an object or an array directly, you should create a new copy with the changes. Adhering to immutability ensures predictability and can help in tracking changes. Applying the ChangeDetectionStrategy.OnPush strategy to components whenever possible is also a good idea as it not only optimizes performance since Angular only evaluates the component for changes when its inputs change or when a bound event is triggered, but it also enforces immutability. Change detection is only activated when a different object instance is passed to the input. Leveraging Angular Router Angular's router is a powerful tool for managing application state. It enables navigation between different parts of an application, allowing parameters to be passed along, effectively using the URL as a single source of truth for your application state, which makes the application more predictable, bookmarkable, and capable of maintaining state across reloads. Moreover, components can subscribe to URL changes and react accordingly. You can also employ router resolvers to fetch data before navigating to a route, ensuring that the necessary state is loaded before the route is activated. However, think carefully about what state you store in the URL; it should ideally only contain the state essential for navigating to a specific view of your application. More ephemeral states, like UI state, should be managed in components or services. Conclusion Angular provides lots of built-in tools and features you can effectively leverage to develop robust, maintainable applications without third-party state management libraries like NgRx. While NgRx is undoubtedly a valuable tool for managing state and side effects in large, complex applications, it may not be necessary for all projects. By employing thoughtful design patterns, such as the Singleton Pattern, adhering to principles of immutability, and leveraging Angular's built-in tools like the Router and Services, you can build a highly maintainable and stateful Angular application or library....

Sep 1, 2023

4 mins

Angular

A Guide to (Typed) Reactive Forms in Angular - Part III (Creating Custom Form Controls)

So far in the series, we have learned the basics of Angular Reactive forms and created some neat logic to construct and display dynamic forms. But our work is still not done yet. Whether we just want to make our controls look good and enhance them with some markup, or whether we need a more complex control than a simple textarea, input or checkbox, we'll either need to use a component library such as Angular Material Components or get familiar with the ControlValueAccessor` interface. Angular Material, by the way, uses ControlValueAccessor` in its components and I recommend looking into the source code if you want to learn some advanced use cases (I have borrowed a lot of their ideas in the past). In this post, however, we will build a basic custom control from scratch. A common requirement for a component that cannot be satisfied by using standard HTML markup I came across in many projects is having a searchable combobox**. So let's build one. We will start by creating a new Angular component and we can do that with a handy ng cli command: ` ng generate component form-fields/combobox ` Then we'll implement displaying data passed in the form of our FormField` class we have defined earlier in a list and allowing for filtering and selecting the options: `TypeScript // combobox.component.ts import { Component, ElementRef, Input, ViewChild } from '@angular/core'; import { FormField } from '../../forms.model'; @Component({ selector: 'app-combobox', templateUrl: './combobox.component.html', styleUrls: ['./combobox.component.scss'], }) export class ComboboxComponent { private filteredOptions?: (string | number)[]; // a simple way to generate a "unique" id for each component // in production, you should rather use a library like uuid public id = String(Date.now() + Math.random()); @ViewChild('input') public input?: ElementRef; public selectedOption = ''; public listboxOpen = false; @Input() public formFieldConfig!: FormField; public get options(): (string | number)[] { return this.filteredOptions || this.formFieldConfig.options || []; } public get label(): string { return this.formFieldConfig.label; } public toggleListbox(): void { this.listboxOpen = !this.listboxOpen; if (this.listboxOpen) { this.input?.nativeElement.focus(); } } public closeListbox(event: FocusEvent): void { // timeout is needed to prevent the list box from closing when clicking on an option setTimeout(() => { this.listboxOpen = false; }, 150); } public filterOptions(filter: string): void { this.filteredOptions = this.formFieldConfig.options?.filter((option) => { return option.toString().toLowerCase().includes(filter.toLowerCase()); }); } public selectOption(option: string | number): void { this.selectedOption = option.toString(); this.listboxOpen = false; } } ` `HTML {{ label }} ▼ {{ option }} ` > Note: For the sake of brevity, we will not be implementing keyboard navigation and aria labels. I strongly suggest referring to W3C WAI patterns to get guidelines on the markup and behavior of an accessible combo box. While our component now looks and behaves like a combo box, it's not a form control yet and is not connected with the Angular forms API. That's where the aforementioned ControlValueAccessor` comes into play along with the `NG_VALUE_ACCESSOR` provider. Let's import them first, update the `@Component` decorator to provide the value accessor, and declare that our component is going to implement the interface: `TypeScript import { ControlValueAccessor, NGVALUE_ACCESSOR } from '@angular/forms'; @Component({ selector: 'app-combobox', templateUrl: './combobox.component.html', styleUrls: ['./combobox.component.scss'], providers: [ { // provide the value accessor provide: NGVALUE_ACCESSOR, // for our combobox component useExisting: ComboboxComponent, // and we don't want to override previously provided value accessors // we want to provide an additional one under the same "NGVALUE_ACCESSOR" token instead multi: true, }, ], }) export class ComboboxComponent implements ControlValueAccessor { ` Now, the component should complain about a few missing methods that we need to satisfy the ControlValueAccessor` interface: - A writeValue` method that is called whenever the form control value is updated from the forms API (e.g. with `patchValue()`). - A registerOnChange` method, which registers a callback function for when the value is changed from the UI. - A registerOnTouched` method that registers a callback function that marks the control when it's been interacted with by the user (typically called in a `blur` handler). - An optional setDisabledState` method that is called when we change the form control `disabled` state- Our (pretty standard) implementation will look like the following: `TypeScript private onChanged!: Function; private onTouched!: Function; public disabled = false; // This will write the value to the view if the form control is updated from outside. public writeValue(value: any) { this.value = value; } // Register a callback function that is called when the control's value changes in the UI. public registerOnChange(onChanged: Function) { this.onChanged = onChanged; } // Register a callback function that is called by the forms API on initialization to update the form model on blur. public registerOnTouched(onTouched: Function) { this.onTouched = onTouched; } public setDisabledState(isDisabled: boolean): void { this.disabled = isDisabled; } public setDisabledState(isDisabled: boolean): void { this.disabled = isDisabled; } ` We don't have to update the template a lot, but we can add [disabled]="disabled"` attribute on our button and input to disable the interactive UI elements if the provided form control was disabled. The rest of the work can be done in the component's TypeScript code. We'll call `this.onTouched()` in our `closeListbox` method, and create a `value` setter that updates our internal value and also notifies the model about the value change: `TypeScript public set value(val: string | number) { this.selectedOption = val.toString(); this.onChanged && this.onChanged(this.selectedOption); this.onTouched && this.onTouched(); } ` You can check out the full implementation on StackBlitz. Conclusion In this series, we've explored the powerful features of Angular reactive forms, including creating and managing dynamic typed forms. We also demonstrated how to use the ControlValueAccessor interface to create custom form controls, such as a searchable combo box. This knowledge will enable you to design complex and dynamic forms in your Angular applications. While the examples provided here are basic, they serve as a solid foundation for building more advanced form controls and implementing validation, accessibility, and other features that are essential for a seamless user experience. By mastering Angular reactive forms and custom form controls, you'll be able to create versatile and maintainable forms in your web applications. If you want to further explore the topic and prefer a form of a video, you can check out an episode of JavaScript Marathon by my amazing colleague Chris. Happy coding!...

Jun 26, 2023

3 mins

Angular

Nuxt DevTools v1.0: Redefining the Developer Experience Beyond Conventional Tools

In the ever-evolving world of web development, Nuxt.js has taken a monumental leap with the launch of Nuxt DevTools v1.0. More than just a set of tools, it's a game-changer—a faithful companion for developers. This groundbreaking release, available for all Nuxt projects and being defaulted from Nuxt v3.8 onwards, marks the beginning of a new era in developer tools. It's designed to simplify our development journey, offering unparalleled transparency, performance, and ease of use. Join me as we explore how Nuxt DevTools v1.0 is set to revolutionize our workflow, making development faster and more efficient than ever. What makes Nuxt DevTools so unique? Alright, let's start delving into the features that make this tool so amazing and unique. There are a lot, so buckle up! In-App DevTools The first thing that caught my attention is that breaking away from traditional browser extensions, Nuxt DevTools v1.0 is seamlessly integrated within your Nuxt app. This ensures universal compatibility across browsers and devices, offering a more stable and consistent development experience. This setup also means the tools are readily available in the app, making your work more efficient. It's a smart move from the usual browser extensions, making it a notable highlight. To use it you just need to press Shift + Option + D` (macOS) or `Shift + Alt + D` (Windows): With simple keystrokes, the Nuxt DevTools v1.0 springs to life directly within your app, ready for action. This integration eliminates the need to toggle between windows or panels, keeping your workflow streamlined and focused. The tools are not only easily accessible but also intelligently designed to enhance your productivity. Pages, Components, and Componsables View The Pages, Components, and Composables View in Nuxt DevTools v1.0 are a clear roadmap for your app. They help you understand how your app is built by simply showing its structure. It's like having a map that makes sense of your app's layout, making the complex parts of your code easier to understand. This is really helpful for new developers learning about the app and experienced developers working on big projects. Pages View lists all your app's pages, making it easier to move around and see how your site is structured. What's impressive is the live update capability. As you explore the DevTools, you can see the changes happening in real-time, giving you instant feedback on your app's behavior. Components View is like a detailed map of all the parts (components) your app uses, showing you how they connect and depend on each other. This helps you keep everything organized, especially in big projects. You can inspect components, change layouts, see their references, and filter them. By showcasing all the auto-imported composables, Nuxt DevTools provides a clear overview of the composables in use, including their source files. This feature brings much-needed clarity to managing composables within large projects. You can also see short descriptions and documentation links in some of them. Together, these features give you a clear picture of your app's layout and workings, simplifying navigation and management. Modules and Static Assets Management This aspect of the DevTools revolutionizes module management. It displays all registered modules, documentation, and repository links, making it easy to discover and install new modules from the community! This makes managing and expanding your app's capabilities more straightforward than ever. On the other hand, handling static assets like images and videos becomes a breeze. The tool allows you to preview and integrate these assets effortlessly within the DevTools environment. These features significantly enhance the ease and efficiency of managing your app's dynamic and static elements. The Runtime Config and Payload Editor The Runtime Config and Payload Editor in Nuxt DevTools make working with your app's settings and data straightforward. The Runtime Config lets you play with different configuration settings in real time, like adjusting settings on the fly and seeing the effects immediately. This is great for fine-tuning your app without guesswork. The Payload Editor is all about managing the data your app handles, especially data passed from server to client. It's like having a direct view and control over the data your app uses and displays. This tool is handy for seeing how changes in data impact your app, making it easier to understand and debug data-related issues. Open Graph Preview The Open Graph Preview in Nuxt DevTools is a feature I find incredibly handy and a real time-saver. It lets you see how your app will appear when shared on social media platforms. This tool is crucial for SEO and social media presence, as it previews the Open Graph tags (like images and descriptions) used when your app is shared. No more deploying first to check if everything looks right – you can now tweak and get instant feedback within the DevTools. This feature not only streamlines the process of optimizing for social media but also ensures your app makes the best possible first impression online. Timeline The Timeline feature in Nuxt DevTools is another standout tool. It lets you track when and how each part of your app (like composables) is called. This is different from typical performance tools because it focuses on the high-level aspects of your app, like navigation events and composable calls, giving you a more practical view of your app's operation. It's particularly useful for understanding the sequence and impact of events and actions in your app, making it easier to spot issues and optimize performance. This timeline view brings a new level of clarity to monitoring your app's behavior in real-time. Production Build Analyzer The Production Build Analyzer feature in Nuxt DevTools v1.0 is like a health check for your app. It looks at your app's final build and shows you how to make it better and faster. Think of it as a doctor for your app, pointing out areas that need improvement and helping you optimize performance. API Playground The API Playground in Nuxt DevTools v1.0 is like a sandbox where you can play and experiment with your app's APIs. It's a space where you can easily test and try out different things without affecting your main app. This makes it a great tool for trying out new ideas or checking how changes might work. Some other cool features Another amazing aspect of Nuxt DevTools is the embedded full-featured VS Code. It's like having your favorite code editor inside the DevTools, with all its powerful features and extensions. It's incredibly convenient for making quick edits or tweaks to your code. Then there's the Component Inspector. Think of it as your code's detective tool. It lets you easily pinpoint and understand which parts of your code are behind specific elements on your page. This makes identifying and editing components a breeze. And remember customization! Nuxt DevTools lets you tweak its UI to suit your style. This means you can set up the tools just how you like them, making your development environment more comfortable and tailored to your preferences. Conclusion In summary, Nuxt DevTools v1.0 marks a revolutionary step in web development, offering a comprehensive suite of features that elevate the entire development process. Features like live updates, easy navigation, and a user-friendly interface enrich the development experience. Each tool within Nuxt DevTools v1.0 is thoughtfully designed to simplify and enhance how developers build and manage their applications. In essence, Nuxt DevTools v1.0 is more than just a toolkit; it's a transformative companion for developers seeking to build high-quality web applications more efficiently and effectively. It represents the future of web development tools, setting new standards in developer experience and productivity....

Dec 1, 2023

8 mins

VueNuxtJSDevToolsJavaScript