The comments are not related to the fix, they are just for future
reference.
The fix is that having an "own" property named `constructor` should
not disqualify an object from being considered an "instance of some
class." Instead, we should detect that an object like
`{constructor: ...}` is a plain object by noting that
`!(x instanceof x.constructor)`.
This included removing some internal version constraints. It would be
nice if package A could say "use B@2.0.0" (when both have changed), but
when they're both in the release, we need to make a release that has a
B@2.0.0-rc in it, which doesn't match that constraint. Fortunately,
constraints aren't necessary within a release anyway.
The react-template-helper package exports a {{> React}} template that
can be used to insert React components into Blaze templates. Due to
the interface that `React.render()` provides, React components rendered
this way must be placed as the only child of their parent element.
Prior to this change, we had runtime (as opposed to compile time) tests
in the react-template-helper package. These tests couldn't detect all
error cases (such as when the sibling is a conditional that starts
empty).
It's unfortunate that this change will make all template compilation
slower but we could improve that later with a change @glasser described
where build plugins can know what other build plugins are running for
the app being built.
TODO: Consider adding an option to `Spacebars.codeGen` with the name
of the template being compiled and add that to the error. This would
bring these errors to the same level as the runtime ones currently
thrown in the react-template-helper package.
The minifier changed the two uses of HTMLTag into two different symbols:
var n = function r() {
var t = this instanceof e.Tag ? this : new r(), n = 0, o = arguments.length && arguments[0];
return o && "object" == typeof o && o.constructor === Object && (t.attrs = o, n++),
n < arguments.length && (t.children = Array.prototype.slice.call(arguments, n)),
t;
};
return n.prototype = new e.Tag(), n.prototype.constructor = n, n.prototype.tagName = t,
n;
Then, IE8 apparently actually creates two separate objects for 'n' and
'r'; see #3 at http://kiro.me/blog/nfe_dilemma.html
So just because n.prototype is an e.Tag doesn't make r.prototype a e.Tag
This means that `new r() instanceof e.Tag` is false, and so the first
line of the function leads to infinite recursion.
I'm not sure if this is an uglify bug as well; dealing well with
multiple declarations of the same function may be out of spec.
Fixes#2037.
