GeezerVison

Notes from the design meeting

If we rewrite references to an imported function func to _ref.func, then rewritten calls to func() will have a this of _ref instead of the default. Potential fix is to rewrite invocations as (0, _ref.func)(args) instead of _ref.func(args) (note that (_ref.func)(args) is not a sufficient fix).

Brian notes that this will be undefined in any ES6 module, so we may not need to really care.

Sheetal Nandi (@sheetalkamat) That should be an error. We currently put all external symbols of a module into scope, but we should exclude those that came from an export declaration. I will fix.

Ryan Cavanaugh (@RyanCavanaugh) Regarding effects of rewriting on this, the same thing happens today with the rewrite we do when referencing exported members of another declaration of the same internal module. It happens everywhere in the compiler, for example. Doesn't appear to be a problem, at least I haven't seen anyone report an issue for it.

Latest commit adds support for export * declarations, including binding, checking, and down-level emit for CommonJS and AMD. Mohamed Hegazy (@mhegazy) Sheetal Nandi (@sheetalkamat) The commit does not include .d.ts emit support.

An example:

// a.ts
export var x = 1;
export var y = 2;
export function foo() {
    console.log("Hello from a");
}

// b.ts
export function foo() {
    console.log("Hello from b");
}
export { foo as bar };
export * from "./a";

// t.ts
import * as a from "./a";
import * as b from "./b";
a.foo();  // Hello from a
b.foo();  // Hello from b
b.bar();  // Hello from b
console.log(a.x);  // 1
console.log(b.x);  // 1

This generates the following when compiled with -m commonjs:

// a.js
exports.x = 1;
exports.y = 2;
function foo() {
    console.log("Hello from a");
}
exports.foo = foo;

// b.js
function foo() {
    console.log("Hello from b");
}
exports.foo = foo;
exports.bar = foo;
var _a = require("./a");
for (var _b in _a) if (!exports.hasOwnProperty(_b)) exports[_b] = _a[_b];

// t.js
var a = require("./a");
var b = require("./b");
a.foo();
b.foo();
b.bar();
console.log(a.x);
console.log(b.x);

Super nice. Thanks!

how to import templates like this with the es6 syntax, please:
var template = require("./file.handlebars");
https://github.com/pcardune/handlebars-loader#your-js-making-use-of-the-templates

Marc Wensauer (@daslicht) First, you need a loader that interpolates them into a named module export, usually this is the export named default.
Then you need an ambient wildcard module declaration so that TypeScript understand that the paths are legal module import targets. That part looks like

declare module '*.handlebars' {
  // export matching the shape produced by the loader.
}

In your case, it looks like using ES2015 module syntax is not supported, and you are stuck with export = and import = as I noticed you commented on pcardune/handlebars-loader#115

First, you need a loader that interpolates them into a named module export, usually this is the export named default.

Any example on that ? please?

I am trying to use handlebars in an TypeScript setup

Marc Wensauer (@daslicht) say I were using SystemJS to load and bundle my application. In that case I would have a setup like this (simplified)

systemjs.config.js

SystemJS.config({
  meta: {
    '*.handlebars': {
      loader: 'text-loader-plugin'
    }
  }
});

If I were using webpack it would look like this (simplified)

webpack.config.js

module.exports = {
  loaders: [
    {
      test: /\.handlebars$/,
      loader: 'text-loader-plugin'
    }
  ]
};

The plugin would sort of look like this (changed and simplified for exposition)

text-loader-plugin.js

export default function (path) {
  const content = load(path); // XHR or fs.readFile
  return { 
    'default': content 
  };
}

Then in my TypeScript project I would have a file like globals.d.ts with the following declaration

globals.d.ts

declare module '*.handlebars' {
  export default '';
}

Then I would use it like this

app/home.ts

import template from 'app/home.handlebars';

OK, thank you !, I keep trying, my approach was using the handlebars-loader:
https://github.com/pcardune/handlebars-loader