Back our Angular 4 Book on Kickstarter.

Creating Source Maps - Building Angular 2 Applications with Gulp - Part 5

This is part of an ongoing series about building Angular 2 TypeScript applications with Gulp. Start with Part 1, and then read Part 2, Part 3, and Part 4.

This entry will teach you about Source Maps. With a TypeScript application, the code running in the browser is not the same as the code we wrote. It has been translated from one language, TypeScript, to another, JavaScript. When an error occurs how can we debug it? The answer is to create a source map. We can look at the source maps in the browser, to learn where we went wrong in the TypeScript code. The usual browser debugging tools, such as break points and watches, will work with source maps.

Install Source Map Plugin

Gulp has a source map plugin that allows us to easily create source maps. First install it:


npm install --save-dev gulp-sourcemaps

You'll see something like this:

The plugin is now available to use within your gulp script.

Generate Source Maps

The first step is to load the source map plugin in your gulpfile.js:


var sourcemaps = require('gulp-sourcemaps');

I am going to add a configuration variable for the location of the maps:


var mapPath = 'maps';

I like to keep my maps separate from the generated code, but you do not have to specify a separate path if you do not prefer.

Now, you can add the source map generation to the buildTS task. First, here is the task unedited:


gulp.task("buildTS", ["tslint"], function() {
return gulp.src(typeScriptSource)
.pipe(tsProject())
.pipe(gulp.dest(destinationPath));
});

There are two steps to the source map generation. The first is to initialize the maps. We want to do this as close to the front of the chain as possible so that the map code can keep track of all the changes. Then we want to save the maps. We want to do this as close to the end of the chain as possible. This is the modified task body:


return gulp.src(typeScriptSource)
.pipe(sourcemaps.init())
.pipe(tsProject())
.pipe(sourcemaps.write(mapPath))
.pipe(gulp.dest(destinationPath));

The second pipe calls the init() method on the source map module. The second to last pipe saves the source maps with the write() method.

Run the task:


gulp buildTS

You'll see this:

Check the build directory:

A source map was generated for each TypeScript source file. Success!

Open up the app in a browser, and bring up the source in your dev tools:

The chrome dev tools let us drill down into the TypeScript files, just as we had written them. They support watches and breakpoints, just as if the browser was running them directly. This is a very useful debug tool.

What's Next?

Te next article in this series I'll show you how to minimize the JavaScript code. Future articles will cover compiling code on the fly, and various different build techniques.

You can get all this information right now by signing up for my newsletter using the form below. Do it to help you become a better Angular 2 Developer.

Get our expanded 38-page version: Building Angular 2 Applications with Gulp.

Copying Static Files - Building Angular 2 Applications with Gulp - Part 4

This is part of an ongoing series about building Angular 2 TypeScript applications with Gulp. Start with Part 1, and then read Part 2, and Part 3.

This entry will show you how to use Gulp to copy files. We'll copy the Angular libraries from the node_modules directory to the build directory, HTML files from the source directory to the build directory, and JavaScript files from the source/js directory to the build directory. These can be done using Gulp directly, you will not need to install additional plugins.

Copy the Angular Libraries

There are a lot of required Angular libraries and we don't want to write a script for each one. Thankfully, we don't have to, as we can specify an array of glob directories to cover all the relevant libraries:


var angularLibraries = [
'core-js/client/shim.min.js',
'zone.js/dist/**',
'reflect-metadata/Reflect.js',
'systemjs/dist/system.src.js',
'@angular/**/
bundles/**',
'rxjs/**/
*.js',
'angular-in-memory-web-api/bundles/in-memory-web-api.umd.js'
]

This covers all the JavaScript libraries required for Angular 2 applications such as zonejs and the shim library. It includes the Angular library bundles and the SystemJS library. The use of globs wildcard match files make it easy to find the relevant files needed.

Next, we'll need a destination path to put the libraries:


var destinationPathForJSLibraries = destinationPath + '/js';

I put all the external libraries in the 'js' directory as an organizational tactic. Now the actual task:


gulp.task('copyAngularLibraries', function () {
gulp.src(angularLibraries, {cwd: "node_modules/**"})
.pipe(gulp.dest(destinationPathForJSLibraries));
});

The task is named copyAngularLibraries. It is simple. It takes the array as a source. The cwd flag with the src specifies the current working directory, meaning all the libraries are located in node_modules. Then the task specifies the destination path. This will copy all the required angular files from the node_modules directory to the build/js directory.

Run this task:


gulp copyAngularLibraries

You should see results like this:

You should see an updated build directory:

This is the first step.

Copy JS Libraries

If we have any JavaScript libraries put in the src/js folder we want to copy those to the build directory. The SystemJS Configuration file is one example. The same approach from above can be used, but is even simpler since there are less directories to deal with.

First, create a glob array to find the JS files:


var javaScriptLibraries = [sourceRoot + 'js/**/*.js'];

Then create the task:


gulp.task('copyJSLibraries', function () {
gulp.src(javaScriptLibraries)
.pipe(gulp.dest(destinationPathForJSLibraries));
});

This is a simple task that specifies the input source and the destination. It uses the same destination variable that was used for the Angular libraries in the previous section.

Run the task:


gulp copyJSLibraries

You'll see this:

Check the build directory and see the final file:

The systemjs.config.js file was successfully copied from the src directory to the build directory.

Copy HTML Files

If you're using my Hello World app, it only has a single HTML file. It is likely that a full app will have more, especially if you use external HTML templates. I want to write a task copy all HTML Files from the src directory to the build directory. First, create a glob array to find the HTML files:


var htmlSource = [sourceRoot + '**/*.html'];

Then create the task:


gulp.task('copyHTML', function () {
return gulp.src(htmlSource)
.pipe(gulp.dest(destinationPath));
});

This is a simple task that specifies the input source and the destination. It uses the same destination variable that was used for the Angular libraries in the previous two sections. It could be easily combined with the copyJSLibraries task, however I prefer to keep them separate for logistical reasons, since HTML files and JS files are different. Run the task:


gulp copyHTML

You'll see this:

Check the build directory and see the final file:

The index.html file was successfully copied from the root of the src folder to the root of the build directory.

If you're using our sample Hello World application, a side effect of finishing this part is that your app will run in the browser:

Not an interesting app, but proof our scripts work.

What's Next?

Even though we have a workable application now; there is still a lot we can do as part of our build scripts. In the next article in this series I'll show you how to create source maps. Later articles will cover JavaScript minificiation, how to compile code on the fly, and various different build techniques. You can get all this information right now by signing up for my newsletter using the form below, so do it and be on your way to become an expert Angular 2 Developer.

Get our expanded 38-page version: Building Angular 2 Applications with Gulp.

Compiling TypeScript - Building Angular 2 Applications with Gulp - Part 3

This is part of an ongoing series about building Angular 2 TypeScript applications with Gulp. Start with Part 1, and then read Part 2.

This section will build a Gulp task for compiling TypeScript into JavaScript.

Install Dependencies

First, install a gulp plugin, gulp-typescript.

Run this code:


npm install --save-dev gulp-typescript

You should see results like this:

This makes the gulp-typescript plugin available for use in our gulpfile.js.

Compile TypeScript to JavaScript

Before we start the compilation task, let's create some variables. First, the destination path for the output files:


var destinationPath = 'build';

I always put the processed files in a directory called build. Then, create an instance of the gulp-typescript module:


var tsc = require("gulp-typescript");

Use the gulp-typescript library to create a project:


var tsProject = tsc.createProject("tsconfig.json");

This refers to an external tsconfig.json file. I don't want to expand on the full details of the config file; but there are two important things I want to draw attention to. The first is a few items in the compilerOptions:


"compilerOptions": {
"target": "es5",
"module": "commonjs",
}

The module type is 'commonjs' which is the module type used behind the scenes by Angular 2. The second important thing here is the target, es5. This stands for EcmaScript 5; JavaScript is an implementation of and most browsers support.

The second important item in the config file is:


"exclude": [
"node_modules"
]

The exclude option tells the type script project not to process files in the node_modules directory. In essence, it ignores all the Angular libraries installed via NodeJS. These libraries already come with compiled bundles. We'll deal with moving those later.

Now, create a buildTS task:


gulp.task("buildTS", ["tslint"], function() {
});

This gulp task is named BuildTS. Before this task is run; the tslint task will execute. The tslint task was created in the previous part of this series. The main task first specifies the source:


return gulp.src(typeScriptSource)

It uses the same typeScriptSource variable that the tslint task used. Then, it adds the tsProject as a gulp pipe:


.pipe(tsProject())

Finally, it specifies the destination path:


.pipe(gulp.dest(destinationPath));

What the full script does is take all the TypeScript files in our source directory, run them through the gulp-typescript compiler, and save the output to a build directory.

Run the script:


gulp buildTS

You'll see results similar to this:

You can see from the output that both the tslint and buildTS process ran. No errors; so let's review the output.

Review Generated JavaScript Code

Look in your project directory and you'll see a brand new build directory:

Each TypeScript file was turned into a JavaScript file. Let's examine the main.js file; as it is simple:


"use strict";
var platform_browser_dynamic_1 = require("@angular/platform-browser-dynamic");
var app_module_1 = require("./app.module");
platform_browser_dynamic_1.platformBrowserDynamic().bootstrapModule(app_module_1.AppModule);

The first thing you'll notice is that the JavaScript iteration replaces the import statements with require statements.

You'll recognize the require statement from the NodeJS code we are writing. However, browsers don't inherently support that. This is here because of commonJS module creation was specified in the compiler options. The systemJS library allows require() to be used in the browser, and that is what Angular 2 uses.

Beyond that, the JavaScript code is not all that different from the original TypeScript code. You can review the other two JS files and you'll find similar results.

What's Next

The first few articles of this series focused on TypeScript, but the full intent is to provide you with everything you need to build your own applications. The next in the series will focus on moving the JavaScript Libraries and HTML files from their install locations to the build directory.

Get our expanded 38-page version: Building Angular 2 Applications with Gulp.

Linting TypeScript - Building Angular 2 Applications with Gulp - Part 2

This is part of an ongoing series about building Angular 2 TypeScript applications with Gulp. Check out Part 1 here.

This section will build a Gulp task for Linting TypeScript. The lint tool is a syntax checker that looks for errors.

Install Dependencies

First, install a NodeJS Plugin, tslint and a gulp plugin, gulp-tslint.

Run this code:


npm install --save-dev tslint gulp-tslint

You should see results like this:

Once the install is complete, you're good to start creating your gulpfile.js

Create the Gulp Lint Task

If you don't already have one, create a file named gulpfile.js in the root directory of the project. Our first task to create is going to lint the TypeScript code. The first step is to import the gulp and gulp-tslint libraries:


var gulp = require("gulp");
var tslint = require('gulp-tslint');

This will make them available for use within our gulp script.

Next, I'm going to define the location of the typeScriptSource:


var sourceRoot = "src/";
var typeScriptSource = [sourceRoot + "**/*.ts"];

This is split up into two variables. The first just points to the source directory and that will be used throughout our script. The second uses the sourceRoot to create a wildcard glob that will cover all existing type script files in the main directory.

Now, create the gulp task to lint the TypeScript:


gulp.task('tslint', function() {
});

This is an empty task that does nothing. Use gulp.src() to tell gulp which items to process:


return gulp.src(typeScriptSource)

Then, run the tslint() task:


.pipe(tslint({
formatter: 'prose'
}))

This will parse the TypeScript, and make a collection of any errors. Then, report the errors:


.pipe(tslint.report());

That is the completed task. Before we run it, we'll need to configure it. Specific configuration options are beyond the scope of this article. Put this tslint.json file, in your root directory and you'll be fine. The file comes from the official Angular 2 Quickstart documentation.

Run the task:


gulp tslint

You'll see something like this:

No issues. What happens when there are issues? I removed a semi-colon and added some random characters to the main.ts file and reran the lint process:

It correctly found the error. The lint process performs a syntax validation; it does not validate the code for accuracy of imports or other bugs; but those will be flagged as part of the compilation process which we'll tackle in part 3.

Get our expanded 38-page version: Building Angular 2 Applications with Gulp.

Directories and SystemJS Config - Building Angular 2 Applications with Gulp - Part 1

I wrote an extended white paper on my Gulp process to compile Angular 2 TypeScript applications, and decided to turn some of it into a series of blog posts. The first part of this series will talk about the directory structure of the project, the initial setup, and SystemJS configuration. By the end of this series you'll have a good architecture for building Angular 2 applications with Gulp.

Directory Structure

You can find all the code for this series in our DotComIt GitHub Repository for project seeds. We structure our projects like this:

  • build: The directory where the compiled code is placed. The root will most contain the main index file.
    • com: Our compiled JavaScript code is put in a com directory, mimicking the package structure of a lot of Java package code. This may also include HTML Templates. For Angular 2 applications, I've seen this directory called 'app' in some uses
    • maps: Source Maps are placed in this directory, if they are generated.
    • js: JavaScript libraries are placed here, if any are required for the project. Some of these are copied over from node_modules, while others may be copied from the src directory.
  • node_modules: A directory that contains relevant modules installed by Node, such as Gulp, TypeScript, and the Angular libraries.
  • src: The directory where our source code goes. The root directory will contain the main index.html file, but not usually much else.
    • com: Our TypeScript code is put in a com directory, mimicking the package structure of a lot of Java package code.
    • js: JavaScript libraries are placed here, if any are required for the project. A default SystemJS Configuration is put in the source directory.

I am not going to examine a sample TypeScript application in detail as part of this series. The GitHub repository includes a simple Hello World application, which will suffice for our demonstration purposes.

Initial NodeJS Setup

Gulp runs on top of NodeJS, so you'll need that. After that, we need to create a package.json in the root directory of your project. Copy and paste this into the file:


{
"name": "TypeScriptAngular2Sample",
"version": "0.0.1",
"description": "TypeScript Angular 2 Sample for Article.",
"author": "Jeffry Houser",
"license": "ISC",
"dependencies": {
"@angular/common": "~2.4.0",
"@angular/compiler": "~2.4.0",
"@angular/core": "~2.4.0",
"@angular/forms": "~2.4.0",
"@angular/http": "~2.4.0",
"@angular/platform-browser": "~2.4.0",
"@angular/platform-browser-dynamic": "~2.4.0",
"@angular/router": "~3.4.0",
"angular-in-memory-web-api": "~0.2.2",
"systemjs": "0.19.40",
"core-js": "^2.4.1",
"reflect-metadata": "^0.1.8",
"rxjs": "5.0.1",
"zone.js": "^0.7.4"
},
"devDependencies": {
"gulp": "^3.9.1",
"typescript": "^2.1.5"
},
"repository": {}
}

This includes all the major Angular 2 libraries and dependencies in the dependency section. The devDependencies section includes Gulp and TypeScript. Install all this stuff with one command:


npm install

You'll see something like this:

This creates the node_modules directory; and installs all the modules specified in the package.json, along with any related dependencies. This is the base we use for creating our build scripts. As we need Gulp plugins we'll install them individually in future installments.

SystemJS Configuration

Angular 2 uses a module loader system named SystemJS to give the browser require() functionality like you'd use on the server side with NodeJS. We need to provide a configuration to SystemJS so that it knows how to find our custom app code, and the required Angular libraries. I put this file in the src/js/systemJSConfig directory.

Setup the file with an Immediately Invoked Function Express (IIFE):


(function (global) {
})(this);

This is the JavaScript method to create a self-executing function. Inside the function, we want to configure SystemJS:


System.config({
});

The config() method is used to configure the SystemJS library. It takes an object, which is currently empty. Add in a paths configuration:


paths: {
'js:': 'js/'
},

This configuration object tells the library that the js path will point to the js directory. When we write build scripts, we'll put all the relevant Angular libraries in the JS sub-directory of our final build. Next, create a map configuration:


map: {
app: 'com',
'@angular/core': 'js:@angular/core/bundles/core.umd.js',
'@angular/common': 'js:@angular/common/bundles/common.umd.js',
'@angular/compiler': 'js:@angular/compiler/bundles/compiler.umd.js',
'@angular/platform-browser': 'js:@angular/platform-browser/bundles/platform-browser.umd.js',
'@angular/platform-browser-dynamic': 'js:@angular/platform-browser-dynamic/bundles/platform-browser-dynamic.umd.js',
'@angular/http': 'js:@angular/http/bundles/http.umd.js',
'@angular/router': 'js:@angular/router/bundles/router.umd.js',
'@angular/forms': 'js:@angular/forms/bundles/forms.umd.js',
'rxjs': 'js:rxjs',
'angular-in-memory-web-api': 'js:angular-in-memory-web-api/bundles/in-memory-web-api.umd.js'
},

The map configuration tells the code 'when we reference 'x' in code; go look for this library. The main angular libraries are listed. Explanation of the Angular libraries are beyond the scope of this article. The important things to notice are that the js path is specified in the file location for most of the libraries. The second thing to notice is that the app map points to our com directory, where all our custom code is located.

Next, specify the packages. A package is a collection of files that have shared functionality:


packages: {
app: {
main: './dotComIt/sample/main/main.js',
defaultExtension: 'js'
},
rxjs: {
defaultExtension: 'js'
}
}

Two packages are specified. The first is app, which is our main application and custom code. It defines the main entry point, main.js--the name of the file that main.ts will be converted too. It also specifies the default extension of js. The second package specified is a package used by Angular, rxjs.

I wanted to cover the SystemJS configuration as part of this article because it is specific to getting Angular to work, but has nothing to do with TypeScript or creating Index files required for the application.

Setup Node and install Angular Dependencies

What's Next

Get our expanded 38-page version: Building Angular 2 Applications with Gulp.

Why doesn't Flex Remoting work with ColdFusion 10 and Apache Web Server?

I'm doing some maintenance on an AIR application with a ColdFusion backend. For testing purposes, I installed a brand new copy of ColdFusion 10 and Apache Web Server 2.2.

My first step was to test this new setup the Flex Remoting connection between ColdFusion and Flex. It was borked! The flex2remoting URL would return a 404. What was wrong? I do not remember having problems in the past. ColdFusion 10 introduced a new version of Flex Remoting, so maybe that was somehow the cause. There are a few people complaining about errors they've encountered. I tried all the fixes.

First, I tried tweaking ColdFusion's urlworkermap.properties file, as described by my good friend Joseph. That didn't work for me. I found another suggestion which recommended commenting out some lines of ColdFusion's web.xml file. No luck there either. I went over all of ColdFusion's Flex Remoting Configs in an attempt to find something amiss, no luck.

I started grasping at straws and experimenting. I know that in IIS, there is a virtual directory called Jakarta which is a Java Mapping and helps Flex Remoting, among other things run. Does Apache have something similar and could the setup be wrong? Apparently the answer is yes! Open up the mod_jk.conf file. It was created when you used the ColdFusion Web Server Configuration Tool to configure the Apache web server. There are a bunch of 'jk' properties:


LoadModule jk_module "C:\ColdFusion10\config\wsconfig\1\mod_jk.so"
JkWorkersFile "C:\ColdFusion10\config\wsconfig\1\workers.properties"
JkMountFile "C:\ColdFusion10\config\wsconfig\1\uriworkermap.properties"

As best I can tell this is the Apache equivalent of the Jakarta mapping in IIS. I started researching the different options around the module loading.

When using virtual hosts with Apache Web Server, the mappings do not trickle down. I added this command to my Apache config:


JkMountCopy All

And everything started working magically.

There are reports of similar problems with CF11. It is frustrating that problems like this still exist.

Submit a Form Post Asyncronously to a New Window with AngularJS - Approach 4

I was working on a client's AngularJS project. When the user clicked a button to open another application, we wanted to make a service call to log the request and make sure we redirected the user to the right place. Some users would see different versions of the other application, and the service call told us the proper variables to pass to setup the secondary app.

Unfortunately, after we made the service call the link would not open. I started to research for more information as to what the problem may be. A browser won't open external pages if they aren't done in response to a user interaction such as clicking a button. The browser assumed user request was ended by the time our service call ended and the promise object resolved.

This is one solution we considered for the issue, which uses a form post to open the new link.

By, the way, this is the fourth in the series about opening links through AngularJS. Check out the first and second, and third .

The Setup

First, add Angular to your Application:


<script src="//ajax.googleapis.com/ajax/libs/angularjs/1.6.0/angular.min.js"></script>

JQuery is also required for this approach:


<script src="https://code.jquery.com/jquery-3.1.1.slim.min.js" ></script>

Then, create an Angular Module and controller:


angular.module('test',[]);
angular.module('test').controller('someController',['$scope','$window','$q', function($scope,$window,$q){
}]);

Three elements are injected into the controller. $scope is the common service used to communicate between the view and the controller. $window gives you an Angular reference to the browser's window object. We'll use $window to open the new page. Finally, $q is added. We are going to use $q to create a promise object to simulate an actual remote service call.

Open the new page

There are multiple steps that we took to create the new page. The new page must be open with user interaction, so let's create the buttons first:


<body ng-app="test">

<div ng-controller="someController">
<button ng-click="onButtonClick(true)" >Open Form Async Success</button>

<button ng-click="onButtonClick(false)" >Open Form Async Refuse</button>

</div>

This code contains two buttons; one that will successfully open the page and another that will not--as if the service call was rejected for reason. Both call the same onButtonClick method, passing in a Boolean value specifying whether the link should be open or not.

Remember to create the form:


<form method="post" action="https://www.jeffryhouser.com" id="myForm" target="myNewWindow">
</form>

An ID is specified, and we'll use this to get a hook to the form inside the angular code. Target is specified, and tells the form to submit to the window named 'myNewWindow'. The form action will post go back to my blog--however you could post it anywhere you want, even passing variables for processing.

Create the stub for the click method:


$scope.onButtonClick = function(openOrClose){
}

The new window must be open in response to the click; so first open the window:


var newWindow = $window.open('about:blank','myCustomWindowTitle');

This uses $window.open() to open the new window and it opens to a blank about page.

Next, make the remote service call, in our case we simulate it using $q. Create the promise:


var defer = $q.defer();

Next, get a link to the form tag:


var form = angular.element('#myForm')

The angular.element is used to get a handle to the form based on the form's ID. This uses JQuery under the hood, but did not work w/ the JQuery lite that is part of AngularJS, so that is why we had to use the full Jquery library earlier.

Write the success and failure functions:


defer.promise.then(function(){
form.submit();
}, function(){
newWindow.close();
});

The failure function will close the new window we created. The success function will submit the form to the new window we just opened.

Now, decide whether to resolve or reject the promise:


if(openOrClose){
defer.resolve();
} else {
defer.reject();
}

The decision is made based on the value of the openOrClose argument passed into the onButtonClick() method.

Load the app and you'll see something like this:

A boring UI. Click the 'refuse' button and the service call is so quick and the window will close as quick as it would open. The user may see a blink, or anomaly in the UI. This is undesirable, but I don't know of another way.

Click the open button, and you'll see this:

The link to my blog will open in a new tab, based on my default browser settings.

Play with the code here.

Final Thoughts

This was an interesting experiment, and it suited my client's need at the time. I always have caution about opening and controlling third party windows on the client's browser; because I don't want to build apps that overstep their bounds.

Open a Link Asyncronously in a New Window with AngularJS - Approach 3

I was working on a client's AngularJS project. When the user clicked a button to open another application, we wanted to make a service call to log the request and make sure we redirected the user to the right place. Some users would see different versions of the other application, and the service call told us the proper variables to pass.

Unfortunately, after we made the service call the link would not open. I started to research for more information as to what the problem may be. Basically, a browser won't open external pages if they aren't done in response to a user interaction such as clicking a button. The browser assumed user request was ended by the time our promise object resolved.

This is how I solved the issue.

By, the way, this is the third in the series about opening links through AngularJS. Check out the first and second.

The Setup

First, add Angular to your Application:


<script src="//ajax.googleapis.com/ajax/libs/angularjs/1.6.0/angular.min.js"></script>

Then, create an Angular Module and controller:


angular.module('test',[]);
angular.module('test').controller('someController',['$scope','$window','$q', function($scope,$window,$q){
}]);

Three elements are injected into the controller. $scope is the common service used to communicate between the view and the controller. $window gives you an Angular reference to the browser's window object. We'll use $window to open the new page. Finally, $q is added. We are going to use $q to create a promise object to simulate an actual remote service call.

Open the new page

There are multiple steps that we took to create the new page. The new page must be open with user interaction, so let's create the buttons first:


<body ng-app="test">

<div ng-controller="someController">
<button ng-click="onButtonClick(true)" >Open Link Async Success</button>

<button ng-click="onButtonClick(false)" >Open Link Async Refuse</button>

</div>

This code contains two buttons; one that will successfully open the page and another that will not--as if the service call was rejected for reason. Both call the same onButtonClick method, passing in a Boolean value specifying whether the link should be open or not:

Create the stub for the method:


$scope.onButtonClick = function(openOrClose){
}

The new window must be open in response to the click; so first open the window:


var newWindow = $window.open('about:blank','myCustomWindowTitle');

This uses $window.open() to open the new window and it opens to a blank about page.

Next, make the remote service call, in our case we simulate it using $q. Create the promise:


var defer = $q.defer();

Write the success and failure functions:


defer.promise.then(function(){
newWindow.location.href = 'https://www.jeffryhouser.com'
}, function(){
newWindow.close();
});

The failure function will close the new window we created. The success function will change the location of the window, in essence opening the new page.

Now, decide whether to resolve or reject the promise:


if(openOrClose){
defer.resolve();
} else {
defer.reject();
}

The decision is made based on the value of the openOrClose argument passed into the onButtonClick() method.

Load the app and you'll see something like this:

A boring UI. Click the 'refuse' button and the service call is so quick and the window will close as quick as it would open. This is undesirable, but I don't know of another way. The user may see a blink.

Click the open button, and you'll see this:

The link to my blog will open in a new tab, based on my default browser settings.

Play with the code here.

What is Next?

The final entry in this series will show you how to submit a form post after asynchronously making a call. That will be out next week.

Submit a Form Post to a New Window with AngularJS - Approach 2

I was working on a client project, built with AngularJS, and we wanted to use AngularJS to submit a form into another window. This could be done with a simple target on the form tag; but we wanted to be able to run other functionality at the time of the form post.

I decided to write a series about the different ways to make this happen; and this is the second in the series. Check out the first.

The Setup

First, add Angular to your Application:


<script src="//ajax.googleapis.com/ajax/libs/angularjs/1.6.0/angular.min.js"></script>

Unfortunately, for this approach we'll need JQuery too:


<script src="https://code.jquery.com/jquery-3.1.1.slim.min.js"></script>

Then, create an Angular Module and controller:


angular.module('test',[]);
angular.module('test').controller('someController',['$scope', function($scope){
}]);

The $scope service is injected into the controller. It is used to share data between the view and the controller.

That is all the required setup.

Open the new page

First, I want to create the form that will be submitted. This is a hidden form with no visual elements:


<form method="post" action="https://www.jeffryhouser.com" id="myForm" target="myNewWindow">
</form>

An ID is specified, and we'll use this to get a hook to the form inside the angular code. Target is specified, and tells the form to submit to the window named 'myNewWindow'. The form action will post go back to my blog--however you could post it anywhere you want, even passing variables for processing.

Add a button to trigger the form, which will open the link in the new window:


<button ng-click="onButtonClick()" >Open Link Form</button>

Back to the JavaScript, this method will open a new page:


$scope.onButtonClick = function(){
var form = angular.element('#myForm')
form.submit();
}

A function named onButtonClick() is saved to the $scope. Inside the button, the angular.element is used to get a handle to the form based on the form's ID. This uses JQuery under the hood, but did not work w/ the JQuery lite that is part of AngularJS, so that is why we had to use the full Jquery library earlier.

Once we get a handle to the form, just submit it.

Now add some HTML:

Load the app and you'll see something like this:

A boring UI; but click the button:

A new tab will open with the form submit; in this case opening my blog:

Play with the code here.

What is Next?

The next entry in this series will show you how to handle links that open inside an asynchronous call. By default browsers won't let you open new windows without user interaction; and that interaction has passed by the time the call is complete. I discovered a workaround, which I'll share.

Open a Link in a New Window with AngularJS - Approach 1

I was working on a client project, built with AngularJS, and we wanted to open another application in a new window. This is a simple, common task, that you can accomplish with an href and a target. But we wanted to look for the most Angular way to accomplish it. Triggering the link in Angular gave us the option to do logging, or other functionality, before the click occurs. I decided to write a series about the different ways to make this happen.

The Setup

First, add Angular to your Application:


<script src="//ajax.googleapis.com/ajax/libs/angularjs/1.6.0/angular.min.js"></script>

Then, create an Angular Module and controller:


angular.module('test',[]);
angular.module('test').controller('someController',['$scope','$window', function($scope,$window){
}]);

Two elements are injected into the controller. $scope is the common service used to communicate between the view and the controller. $window gives you an Angular reference to the browser's window object. We'll use $window to open the new page.

Open the new page

This method will open a new page:


$scope.onButtonClick = function(){
$window.open('https://www.jeffryhouser.com');
}

A function named onButtonClick() is saved to the $scope. Inside the button, the $window.open() method is called. This will force the window to open the URL in a new window.

Now add some HTML:


<body ng-app="test">

<div ng-controller="someController">
<button ng-click="onButtonClick()" >Open Link Standard</button>
</div>

The ngApp tag is put on the body. The ngController is put on a div. A button inside the div uses ngClick to call the onButtonClick() method.

Load the app and you'll see something like this:

A boring UI; but click the button:

The link to my blog will open in a new tab, based on my default browser settings.

Play with the code here.

What is Next?

The next entry in this series will show you how to use a similar approach to submit a form into a new window. Then, I'll write an entry about holding off on opening the new window until after an asynchronous call is complete. The last part is where things start to get complicated; but bear with me. We'll get there quickly.

More Entries

All Content Copyright 2005, 2006, 2007, 2008, 2009 Jeffry Houser. May not be reused without permission
BlogCFC was created by Raymond Camden. This blog is running version 5.9.2.002.