npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

ngtemplate-typescript-loader

v2.1.1

Published

Include AngularJS templates in the Webpack bundle and preload the template cache.

Downloads

216

Readme

AngularJS Template loader for webpack

This is a fork of the ngtemplate-loader with a few quality of life updates.

Includes your AngularJS templates into your webpack Javascript Bundle. Pre-loads the AngularJS template cache to remove initial load times of templates.

ngTemplate loader does not minify or process your HTML at all, and instead uses the standard loaders such as html-loader or raw-loader. This gives you the flexibility to pick and choose your HTML loaders.

Install

npm install ngtemplate-typescript-loader --save-dev

Usage

Documentation: Using loaders

ngTemplate loader will export the path of the HTML file, so you can use require directly AngularJS with templateUrl parameters e.g.

var templateUrl = require('ngtemplate!html!./test.html');

app.directive('testDirective', function() {
    return {
        restrict: 'E',
        templateUrl: templateUrl
    }
});

To remove the extra require, check out the Baggage Example below.

ngTemplate creates a JS module that initialises the $templateCache with the HTML under the file path e.g.

require('!ngtemplate?relativeTo=/projects/test/app!html!file.html');
// => generates the javascript:
// angular.module('ng').run(['$templateCache', function(c) { c.put('file.html', '<file.html processed by html-loader>') }]);

Beware of requiring from the directive definition

The following code is wrong, Because it'll operate only after angular bootstraps:

app.directive('testDirective', function() {
    return {
        restrict: 'E',
        templateUrl: require('ngtemplate!html!./test.html') // <- WRONG !
    }
});

relativeTo and prefix

You can set the base path of your templates using relativeTo and prefix parameters. relativeTo is used to strip a matching prefix from the absolute path of the input html file. prefix is then appended to path.

The prefix of the path up to and including the first relativeTo match is stripped, e.g.

// webpack.config.js
module.exports = {
  module: {
    loaders: [
      {
        test: /\.html$/,
        loader: 'ngtemplate-typescript-loader',
        options: {
          relativeTo: '/src/'
        }
      }
    ]
  }
};
// file in which the html file is imported
require('/test/src/test.html');
// c.put('test.html', ...)

You can also set the relativeTo parameter to an array of strings and this allows you to strip paths for multiple possible parameters. The parameter to match eariliest in the path will be where the loader strips the path from:

// webpack.config.js
module.exports = {
  module: {
    loaders: [
      {
        test: /\.html$/,
        loader: 'ngtemplate-typescript-loader',
        options: {
          relativeTo: ['/src/', '/node_modules/'],
          exportAsEs6Default: true
        }
      }
    ]
  }
};
// file in which the html file is imported
import templateUrl from '../../node_modules/test/src/test.html';
// c.put('test/src/test.html', ...)
import templateUrl from './test/src/test.html'
// c.put('test.html', ...)

To match the from the start of the absolute path prefix a '//', e.g.

require('!ngtemplate?relativeTo=//Users/WearyMonkey/project/test/!html!/test/src/test.html');
// c.put('src/test.html', ...)

You can combine relativeTo and prefix to replace the prefix in the absolute path, e.g.

require('!ngtemplate?relativeTo=src/&prefix=build/!html!/test/src/test.html');
// c.put('build/test.html', ...)

module

By default ngTemplate loader adds a run method to the global 'ng' module which does not need to explicitly required by your app. You can override this by setting the module parameter, e.g.

require('!ngtemplate?module=myTemplates&relativeTo=/projects/test/app!html!file.html');
// => returns the javascript:
// angular.module('myTemplates').run(['$templateCache', function(c) { c.put('file.html', '<file.html processed by html-loader>') }]);

Parameter Interpolation

module, relativeTo and prefix parameters are interpolated using Webpack's standard interpolation rules. Interpolation regular expressions can be passed using the extra parameters moduleRegExp, relativeToRegExp and prefixRegExp which apply to single parameters, or regExp which will apply to all three parameters.

Path Separators (Or using on Windows)

By default, ngTemplate loader will assume you are using unix style path separators '/' for html paths in your project. e.g. templateUrl: '/views/app.html'. If however you want to use Window's style path separators '' e.g. templateUrl: '\\views\\app.html' you can override the separator by providing the pathSep parameter.

require('ngtemplate?pathSep=\\!html!.\\test.html')

Make sure you use the same path separator for the prefix and relativeTo parameters, all templateUrls and in your webpack.config.js file.

Export formats

There are different export formats available:

  • module.exports (default, cjs format). "myTemplateUrl" becomes module.exports = "myTemplateUrl";
  • exports.default (when exportAsDefault param is set, es6to5 format). "myTemplateUrl" becomes exports.default = "myTemplateUrl";
  • export default (when exportAsEs6Default param is set, es6 format). "myTemplateUrl" becomes export default "myTemplateUrl";

Using with npm requires

This module relies on angular being available on window object. However, in cases angular is connected from node_modules via require('angular'), option to force this module to get the angular should be used:

require('!ngtemplate?requireAngular!html!file.html');

// => generates the javascript:
// var angular = require('angular');
// angular.module('ng').run(['$templateCache', function(c) { c.put('file.html', '<file.html processed by html-loader>') }]);

Webpack Config

module.exports = {
  module: {
    loaders: [
      {
        test: /\.html$/,
        loader: 'ngtemplate-typescript-loader',
        options: {
          relativeTo: '/app'
        }
      }
    ]
  }
};

Dynamic Requires

Webpack's dynamic requires do not implicitly call the IIFE wrapping each call to window.angular.module('ng').run(...), so if you use them to require a folder full of partials, you must manually iterate through the resulting object and resolve each dependency in order to accomodate angular's side-effects oriented module system:

var templates = require.context('.', false, /\.html$/);

templates.keys().forEach(function(key) {
  templates(key);
});

Baggage Example

ngTemplate loader works well with the Baggage Loader to remove all those extra HTML and CSS requires. See an example of a directive and webpack.config.js below. Or take a look at more complete example in the examples/baggage folder.

With a folder structure:

app/
├── app.js
├── index.html
├── webpack.config.js
└── my-directive/
    ├── my-directive.js
    ├── my-directive.css
    └── my-directive.html

and a webpack.config.js like:

module.exports = {
  module: {
    preLoaders: [
      {
        test: /\.js$/,
        loader: 'baggage?[file].html&[file].css'
      }
    ],
    loaders: [
      {
        test: /\.html$/,
        loader: 'ngtemplate?relativeTo=' + __dirname + '/!html'
      }
    ]
  }
};

You can now skip the initial require of html and css like so:

app.directive('myDirective', function() {
    return {
        restrict: 'E',
        templateUrl: require('./my-directive.html')
    }
});

License

MIT (http://www.opensource.org/licenses/mit-license.php)