In this post, we will look into an approach for exchanging the definition of an AngularJS directive, i.e. the template, controller, compile/link functions etc., after the application has been bootstrapped whereby carrying out a full reload is not an option.

Assume that you have an application that allows the user to have multiple accounts to switch between. Depending on the currently active account, the application establishes a connection to different servers that in turn have different definitions for the same AngularJS directive.

Here is a simplified example:

<!-- the user is not logged in => show nothing (or some default content) -->
<my-directive message="'Hello World'" />

---------------------------------------------------------------------------------

<!-- the user is connected to “server A” => fetch and apply the directive definition delivered by “server A” 
{
	restrict: 'E',
	template: '<div>Coming from Server A</div>'
};
-->
<my-directive>
	<div>Coming from the Server A</div>
</my-directive>

---------------------------------------------------------------------------------

<!-- the user is connected to “server B” => fetch and apply the directive delivered by “server B”
{
	restrict: 'E',
	scope: {
		message: '='
	},
	template: '<span>And now from Server B: {{message}}</span>'
};
-->
<my-directive>
	<span>And now from Server B: Hello World</span>
</my-directive>

To be able to exchange the entire definition of an AngularJS directive after the application has started we need to address the following problems:

  • Lazy loading
  • Directive definition exchange
  • On-demand recompilation

Let’s have a look at each point in more detail now.

1) Lazy loading

Problem: The usual way to register a directive does not work after the application has bootstrapped.

// the usual way to register a directive
angular.module('app').directive('myDirective', MyDirective);

For the registration of an AngularJS directive after the application has started, we need the $compileProvider. We can get a hold of the $compileProvider during the configuration phase, and save the reference somewhere we get access to later, like in a service (in our example it will be the dynamicDirectiveManager).

// grab the $compileProvider
angular.module('app')
	.config(function ($compileProvider, dynamicDirectiveManagerProvider) {
		dynamicDirectiveManagerProvider.setCompileProvider($compileProvider);
	});

// Later on, we are able to register new directives using the $compileProvider
$compileProvider.directive.apply(null, [name, constructor]);

By using the $compileProvider we are now able to lazy-load directives.

2) Directive definition exchange

Problem: Re-registering a directive using the same name but different definition (i.e. template, controller, etc.) does not work.

$compileProvider.directive
	.apply(null, [ 'myDirective', function() { return { template: 'Template A',} } ]);

// … some time later …
$compileProvider.directive
	.apply(null, [ 'myDirective', function() { return { template: 'Other template',} } ]); 
// the previous statement won’t overwrite the directive

Due to caching in AngularJS, the directives that we are trying to overwrite are not going to be exchanged by a new one. To remedy this problem, we have no other choice but to change the name in some way, for example by appending a suffix. Luckily, we can hide this renaming in the previously mentioned dynamicDirectiveManager.

// will compile to <my-directive-optionalsuffix>
dynamicDirectiveManager.registerDirective('myDirective', function() { return { template: 'Template',} }, 'optionalsuffix');

// … some time later …
// will compile to <my-directive-randomsuffix>
dynamicDirectiveManager.registerDirective('myDirective', function() { return { template: 'Other template',} });

3) On-demand recompilation

Problem: Now, we are able to exchange a directive definition by a new one but the corresponding directives on our HTML page will not recompile themselves, especially if the directives (except for markup in the page) did not exist at all a moment ago.

To be able to recompile the directives on demand, the desired directive will be created by another one (say ) that we have full control over. That way we can call $compile() every time a directive has been overwritten.

<!-- Remark: the attribute “message” has no meaning for the <dynamic-directive> but for <my-directive> -->

<!-- dynamic directive … -->
<dynamic-directive element-name="my-directive" message="'Hello World'"></dynamic-directive>
<!-- or -->
<dynamic-directive element-name="{{getDirectiveName()}}" message="'Hello World'"></dynamic-directive>

<!-- … will initially compile into something like … -->
<dynamic-directive element-name="my-directive" message="'Hello World'">
	<my-directive message="'Hello World'" />
</dynamic-directive>

<!-- … and after a registration of a new directive definition … -->
<dynamic-directive element-name="my-directive" message="'Hello World'">
	<my-directive-someprefix message="'Hello World'" />
</dynamic-directive>

<!-- from now on, the <my-directive> is on its own, at least until the next exchange of the directive definition … -->

By using the $compile service, we solved one problem but created a memory leak. If the inner directive () requests an isolated or child scope, then we get a deserted scope on each recompile thereby slowing the whole application bit by bit.

To solve this issue, we need to check whether the scope of the inner directive is different than the scope of the . If so, then the inner scope will be disposed of by calling $destroy().

var innerScope = currentInnerElement.isolateScope() || currentInnerElement.scope();

if (innerScope && (innerScope !== scope)) {
	innerScope.$destroy();
}

Voilà!

Conclusion

This is a quite special case and it requires quite some code just to overwrite a directive without restarting the application. Luckily, the bulk of the work is done either by the or by dynamicDirectiveManager.

Live working example

http://jsfiddle.net/Pawel_Gerr/y22ZK/

Related Articles

tools
Introduction: Mocking and Manipulating API Behavior with a Local Proxy Server - Part 1
In this five-part article series, you will learn how to manipulate your API behavior with a local proxy server. When it comes to developing against an HTTPS/REST API, which we do not control ourselves, we face many problems regularly. Issues and hard to provoke edge cases may…
Thinktecture Team
electron
Electron Anwendungen paketieren mit dem electron-packager: Cross-Plattform Desktop Apps - Teil 5 [Screencast]
Thinktecture Cloud-Native- und Infrastructure-as-Code-Spezialist Thorsten Hans erklärt in einer fünfteiligen Screencast-Serie das Framework Electron. Nach den Grundlagen und der Architektur, Developer-Essentials, der UX-Optimierung und Security-Maßnahmen, geht es im letzten Teil…
Thorsten Hans
entity framework core
Do Not Waste Performance by Not Using Temp Tables With Entity Framework Core
It has been a while since I released my article about the usage of temp tables in Entity Framework (v6). Meanwhile, Microsoft has released a completely rewritten version of its O/R mapper so my old approach is no longer applicable. But before we learn about a new one, let us…
Pawel Gerr
web components
Data Sharing & Framework Integration: Perks & Flaws Series - Part 4
In this four part article series, we are exploring the perks, flaws, and current standards of forming Web Components. This last article will teach you how Web Components can share data and services, and which role frameworks play. Article Series The Motivation for using Web…
Manuel Rauber