| /** |
| * @license Angular v8.1.1 |
| * (c) 2010-2019 Google LLC. https://angular.io/ |
| * License: MIT |
| */ |
| |
| (function (global, factory) { |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : |
| typeof define === 'function' && define.amd ? define('@angular/compiler', ['exports'], factory) : |
| (global = global || self, factory((global.ng = global.ng || {}, global.ng.compiler = {}))); |
| }(this, function (exports) { 'use strict'; |
| |
| /*! *****************************************************************************
|
| Copyright (c) Microsoft Corporation. All rights reserved.
|
| Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
| this file except in compliance with the License. You may obtain a copy of the
|
| License at http://www.apache.org/licenses/LICENSE-2.0
|
|
|
| THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
| KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
|
| WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
|
| MERCHANTABLITY OR NON-INFRINGEMENT.
|
|
|
| See the Apache Version 2.0 License for specific language governing permissions
|
| and limitations under the License.
|
| ***************************************************************************** */
|
| /* global Reflect, Promise */
|
|
|
| var extendStatics = function(d, b) {
|
| extendStatics = Object.setPrototypeOf ||
|
| ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
| function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
| return extendStatics(d, b);
|
| };
|
|
|
| function __extends(d, b) {
|
| extendStatics(d, b);
|
| function __() { this.constructor = d; }
|
| d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
| }
|
|
|
| var __assign = function() {
|
| __assign = Object.assign || function __assign(t) {
|
| for (var s, i = 1, n = arguments.length; i < n; i++) {
|
| s = arguments[i];
|
| for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
|
| }
|
| return t;
|
| };
|
| return __assign.apply(this, arguments);
|
| };
|
|
|
| function __values(o) {
|
| var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
|
| if (m) return m.call(o);
|
| return {
|
| next: function () {
|
| if (o && i >= o.length) o = void 0;
|
| return { value: o && o[i++], done: !o };
|
| }
|
| };
|
| }
|
|
|
| function __read(o, n) {
|
| var m = typeof Symbol === "function" && o[Symbol.iterator];
|
| if (!m) return o;
|
| var i = m.call(o), r, ar = [], e;
|
| try {
|
| while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
| }
|
| catch (error) { e = { error: error }; }
|
| finally {
|
| try {
|
| if (r && !r.done && (m = i["return"])) m.call(i);
|
| }
|
| finally { if (e) throw e.error; }
|
| }
|
| return ar;
|
| }
|
|
|
| function __spread() {
|
| for (var ar = [], i = 0; i < arguments.length; i++)
|
| ar = ar.concat(__read(arguments[i]));
|
| return ar;
|
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| (function (TagContentType) { |
| TagContentType[TagContentType["RAW_TEXT"] = 0] = "RAW_TEXT"; |
| TagContentType[TagContentType["ESCAPABLE_RAW_TEXT"] = 1] = "ESCAPABLE_RAW_TEXT"; |
| TagContentType[TagContentType["PARSABLE_DATA"] = 2] = "PARSABLE_DATA"; |
| })(exports.TagContentType || (exports.TagContentType = {})); |
| function splitNsName(elementName) { |
| if (elementName[0] != ':') { |
| return [null, elementName]; |
| } |
| var colonIndex = elementName.indexOf(':', 1); |
| if (colonIndex == -1) { |
| throw new Error("Unsupported format \"" + elementName + "\" expecting \":namespace:name\""); |
| } |
| return [elementName.slice(1, colonIndex), elementName.slice(colonIndex + 1)]; |
| } |
| // `<ng-container>` tags work the same regardless the namespace |
| function isNgContainer(tagName) { |
| return splitNsName(tagName)[1] === 'ng-container'; |
| } |
| // `<ng-content>` tags work the same regardless the namespace |
| function isNgContent(tagName) { |
| return splitNsName(tagName)[1] === 'ng-content'; |
| } |
| // `<ng-template>` tags work the same regardless the namespace |
| function isNgTemplate(tagName) { |
| return splitNsName(tagName)[1] === 'ng-template'; |
| } |
| function getNsPrefix(fullName) { |
| return fullName === null ? null : splitNsName(fullName)[0]; |
| } |
| function mergeNsAndName(prefix, localName) { |
| return prefix ? ":" + prefix + ":" + localName : localName; |
| } |
| // see http://www.w3.org/TR/html51/syntax.html#named-character-references |
| // see https://html.spec.whatwg.org/multipage/entities.json |
| // This list is not exhaustive to keep the compiler footprint low. |
| // The `{` / `ƫ` syntax should be used when the named character reference does not |
| // exist. |
| var NAMED_ENTITIES = { |
| 'Aacute': '\u00C1', |
| 'aacute': '\u00E1', |
| 'Acirc': '\u00C2', |
| 'acirc': '\u00E2', |
| 'acute': '\u00B4', |
| 'AElig': '\u00C6', |
| 'aelig': '\u00E6', |
| 'Agrave': '\u00C0', |
| 'agrave': '\u00E0', |
| 'alefsym': '\u2135', |
| 'Alpha': '\u0391', |
| 'alpha': '\u03B1', |
| 'amp': '&', |
| 'and': '\u2227', |
| 'ang': '\u2220', |
| 'apos': '\u0027', |
| 'Aring': '\u00C5', |
| 'aring': '\u00E5', |
| 'asymp': '\u2248', |
| 'Atilde': '\u00C3', |
| 'atilde': '\u00E3', |
| 'Auml': '\u00C4', |
| 'auml': '\u00E4', |
| 'bdquo': '\u201E', |
| 'Beta': '\u0392', |
| 'beta': '\u03B2', |
| 'brvbar': '\u00A6', |
| 'bull': '\u2022', |
| 'cap': '\u2229', |
| 'Ccedil': '\u00C7', |
| 'ccedil': '\u00E7', |
| 'cedil': '\u00B8', |
| 'cent': '\u00A2', |
| 'Chi': '\u03A7', |
| 'chi': '\u03C7', |
| 'circ': '\u02C6', |
| 'clubs': '\u2663', |
| 'cong': '\u2245', |
| 'copy': '\u00A9', |
| 'crarr': '\u21B5', |
| 'cup': '\u222A', |
| 'curren': '\u00A4', |
| 'dagger': '\u2020', |
| 'Dagger': '\u2021', |
| 'darr': '\u2193', |
| 'dArr': '\u21D3', |
| 'deg': '\u00B0', |
| 'Delta': '\u0394', |
| 'delta': '\u03B4', |
| 'diams': '\u2666', |
| 'divide': '\u00F7', |
| 'Eacute': '\u00C9', |
| 'eacute': '\u00E9', |
| 'Ecirc': '\u00CA', |
| 'ecirc': '\u00EA', |
| 'Egrave': '\u00C8', |
| 'egrave': '\u00E8', |
| 'empty': '\u2205', |
| 'emsp': '\u2003', |
| 'ensp': '\u2002', |
| 'Epsilon': '\u0395', |
| 'epsilon': '\u03B5', |
| 'equiv': '\u2261', |
| 'Eta': '\u0397', |
| 'eta': '\u03B7', |
| 'ETH': '\u00D0', |
| 'eth': '\u00F0', |
| 'Euml': '\u00CB', |
| 'euml': '\u00EB', |
| 'euro': '\u20AC', |
| 'exist': '\u2203', |
| 'fnof': '\u0192', |
| 'forall': '\u2200', |
| 'frac12': '\u00BD', |
| 'frac14': '\u00BC', |
| 'frac34': '\u00BE', |
| 'frasl': '\u2044', |
| 'Gamma': '\u0393', |
| 'gamma': '\u03B3', |
| 'ge': '\u2265', |
| 'gt': '>', |
| 'harr': '\u2194', |
| 'hArr': '\u21D4', |
| 'hearts': '\u2665', |
| 'hellip': '\u2026', |
| 'Iacute': '\u00CD', |
| 'iacute': '\u00ED', |
| 'Icirc': '\u00CE', |
| 'icirc': '\u00EE', |
| 'iexcl': '\u00A1', |
| 'Igrave': '\u00CC', |
| 'igrave': '\u00EC', |
| 'image': '\u2111', |
| 'infin': '\u221E', |
| 'int': '\u222B', |
| 'Iota': '\u0399', |
| 'iota': '\u03B9', |
| 'iquest': '\u00BF', |
| 'isin': '\u2208', |
| 'Iuml': '\u00CF', |
| 'iuml': '\u00EF', |
| 'Kappa': '\u039A', |
| 'kappa': '\u03BA', |
| 'Lambda': '\u039B', |
| 'lambda': '\u03BB', |
| 'lang': '\u27E8', |
| 'laquo': '\u00AB', |
| 'larr': '\u2190', |
| 'lArr': '\u21D0', |
| 'lceil': '\u2308', |
| 'ldquo': '\u201C', |
| 'le': '\u2264', |
| 'lfloor': '\u230A', |
| 'lowast': '\u2217', |
| 'loz': '\u25CA', |
| 'lrm': '\u200E', |
| 'lsaquo': '\u2039', |
| 'lsquo': '\u2018', |
| 'lt': '<', |
| 'macr': '\u00AF', |
| 'mdash': '\u2014', |
| 'micro': '\u00B5', |
| 'middot': '\u00B7', |
| 'minus': '\u2212', |
| 'Mu': '\u039C', |
| 'mu': '\u03BC', |
| 'nabla': '\u2207', |
| 'nbsp': '\u00A0', |
| 'ndash': '\u2013', |
| 'ne': '\u2260', |
| 'ni': '\u220B', |
| 'not': '\u00AC', |
| 'notin': '\u2209', |
| 'nsub': '\u2284', |
| 'Ntilde': '\u00D1', |
| 'ntilde': '\u00F1', |
| 'Nu': '\u039D', |
| 'nu': '\u03BD', |
| 'Oacute': '\u00D3', |
| 'oacute': '\u00F3', |
| 'Ocirc': '\u00D4', |
| 'ocirc': '\u00F4', |
| 'OElig': '\u0152', |
| 'oelig': '\u0153', |
| 'Ograve': '\u00D2', |
| 'ograve': '\u00F2', |
| 'oline': '\u203E', |
| 'Omega': '\u03A9', |
| 'omega': '\u03C9', |
| 'Omicron': '\u039F', |
| 'omicron': '\u03BF', |
| 'oplus': '\u2295', |
| 'or': '\u2228', |
| 'ordf': '\u00AA', |
| 'ordm': '\u00BA', |
| 'Oslash': '\u00D8', |
| 'oslash': '\u00F8', |
| 'Otilde': '\u00D5', |
| 'otilde': '\u00F5', |
| 'otimes': '\u2297', |
| 'Ouml': '\u00D6', |
| 'ouml': '\u00F6', |
| 'para': '\u00B6', |
| 'permil': '\u2030', |
| 'perp': '\u22A5', |
| 'Phi': '\u03A6', |
| 'phi': '\u03C6', |
| 'Pi': '\u03A0', |
| 'pi': '\u03C0', |
| 'piv': '\u03D6', |
| 'plusmn': '\u00B1', |
| 'pound': '\u00A3', |
| 'prime': '\u2032', |
| 'Prime': '\u2033', |
| 'prod': '\u220F', |
| 'prop': '\u221D', |
| 'Psi': '\u03A8', |
| 'psi': '\u03C8', |
| 'quot': '\u0022', |
| 'radic': '\u221A', |
| 'rang': '\u27E9', |
| 'raquo': '\u00BB', |
| 'rarr': '\u2192', |
| 'rArr': '\u21D2', |
| 'rceil': '\u2309', |
| 'rdquo': '\u201D', |
| 'real': '\u211C', |
| 'reg': '\u00AE', |
| 'rfloor': '\u230B', |
| 'Rho': '\u03A1', |
| 'rho': '\u03C1', |
| 'rlm': '\u200F', |
| 'rsaquo': '\u203A', |
| 'rsquo': '\u2019', |
| 'sbquo': '\u201A', |
| 'Scaron': '\u0160', |
| 'scaron': '\u0161', |
| 'sdot': '\u22C5', |
| 'sect': '\u00A7', |
| 'shy': '\u00AD', |
| 'Sigma': '\u03A3', |
| 'sigma': '\u03C3', |
| 'sigmaf': '\u03C2', |
| 'sim': '\u223C', |
| 'spades': '\u2660', |
| 'sub': '\u2282', |
| 'sube': '\u2286', |
| 'sum': '\u2211', |
| 'sup': '\u2283', |
| 'sup1': '\u00B9', |
| 'sup2': '\u00B2', |
| 'sup3': '\u00B3', |
| 'supe': '\u2287', |
| 'szlig': '\u00DF', |
| 'Tau': '\u03A4', |
| 'tau': '\u03C4', |
| 'there4': '\u2234', |
| 'Theta': '\u0398', |
| 'theta': '\u03B8', |
| 'thetasym': '\u03D1', |
| 'thinsp': '\u2009', |
| 'THORN': '\u00DE', |
| 'thorn': '\u00FE', |
| 'tilde': '\u02DC', |
| 'times': '\u00D7', |
| 'trade': '\u2122', |
| 'Uacute': '\u00DA', |
| 'uacute': '\u00FA', |
| 'uarr': '\u2191', |
| 'uArr': '\u21D1', |
| 'Ucirc': '\u00DB', |
| 'ucirc': '\u00FB', |
| 'Ugrave': '\u00D9', |
| 'ugrave': '\u00F9', |
| 'uml': '\u00A8', |
| 'upsih': '\u03D2', |
| 'Upsilon': '\u03A5', |
| 'upsilon': '\u03C5', |
| 'Uuml': '\u00DC', |
| 'uuml': '\u00FC', |
| 'weierp': '\u2118', |
| 'Xi': '\u039E', |
| 'xi': '\u03BE', |
| 'Yacute': '\u00DD', |
| 'yacute': '\u00FD', |
| 'yen': '\u00A5', |
| 'yuml': '\u00FF', |
| 'Yuml': '\u0178', |
| 'Zeta': '\u0396', |
| 'zeta': '\u03B6', |
| 'zwj': '\u200D', |
| 'zwnj': '\u200C', |
| }; |
| // The &ngsp; pseudo-entity is denoting a space. see: |
| // https://github.com/dart-lang/angular/blob/0bb611387d29d65b5af7f9d2515ab571fd3fbee4/_tests/test/compiler/preserve_whitespace_test.dart |
| var NGSP_UNICODE = '\uE500'; |
| NAMED_ENTITIES['ngsp'] = NGSP_UNICODE; |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var HtmlTagDefinition = /** @class */ (function () { |
| function HtmlTagDefinition(_a) { |
| var _this = this; |
| var _b = _a === void 0 ? {} : _a, closedByChildren = _b.closedByChildren, implicitNamespacePrefix = _b.implicitNamespacePrefix, _c = _b.contentType, contentType = _c === void 0 ? exports.TagContentType.PARSABLE_DATA : _c, _d = _b.closedByParent, closedByParent = _d === void 0 ? false : _d, _e = _b.isVoid, isVoid = _e === void 0 ? false : _e, _f = _b.ignoreFirstLf, ignoreFirstLf = _f === void 0 ? false : _f; |
| this.closedByChildren = {}; |
| this.closedByParent = false; |
| this.canSelfClose = false; |
| if (closedByChildren && closedByChildren.length > 0) { |
| closedByChildren.forEach(function (tagName) { return _this.closedByChildren[tagName] = true; }); |
| } |
| this.isVoid = isVoid; |
| this.closedByParent = closedByParent || isVoid; |
| this.implicitNamespacePrefix = implicitNamespacePrefix || null; |
| this.contentType = contentType; |
| this.ignoreFirstLf = ignoreFirstLf; |
| } |
| HtmlTagDefinition.prototype.isClosedByChild = function (name) { |
| return this.isVoid || name.toLowerCase() in this.closedByChildren; |
| }; |
| return HtmlTagDefinition; |
| }()); |
| var _DEFAULT_TAG_DEFINITION; |
| // see http://www.w3.org/TR/html51/syntax.html#optional-tags |
| // This implementation does not fully conform to the HTML5 spec. |
| var TAG_DEFINITIONS; |
| function getHtmlTagDefinition(tagName) { |
| if (!TAG_DEFINITIONS) { |
| _DEFAULT_TAG_DEFINITION = new HtmlTagDefinition(); |
| TAG_DEFINITIONS = { |
| 'base': new HtmlTagDefinition({ isVoid: true }), |
| 'meta': new HtmlTagDefinition({ isVoid: true }), |
| 'area': new HtmlTagDefinition({ isVoid: true }), |
| 'embed': new HtmlTagDefinition({ isVoid: true }), |
| 'link': new HtmlTagDefinition({ isVoid: true }), |
| 'img': new HtmlTagDefinition({ isVoid: true }), |
| 'input': new HtmlTagDefinition({ isVoid: true }), |
| 'param': new HtmlTagDefinition({ isVoid: true }), |
| 'hr': new HtmlTagDefinition({ isVoid: true }), |
| 'br': new HtmlTagDefinition({ isVoid: true }), |
| 'source': new HtmlTagDefinition({ isVoid: true }), |
| 'track': new HtmlTagDefinition({ isVoid: true }), |
| 'wbr': new HtmlTagDefinition({ isVoid: true }), |
| 'p': new HtmlTagDefinition({ |
| closedByChildren: [ |
| 'address', 'article', 'aside', 'blockquote', 'div', 'dl', 'fieldset', |
| 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', |
| 'h6', 'header', 'hgroup', 'hr', 'main', 'nav', 'ol', |
| 'p', 'pre', 'section', 'table', 'ul' |
| ], |
| closedByParent: true |
| }), |
| 'thead': new HtmlTagDefinition({ closedByChildren: ['tbody', 'tfoot'] }), |
| 'tbody': new HtmlTagDefinition({ closedByChildren: ['tbody', 'tfoot'], closedByParent: true }), |
| 'tfoot': new HtmlTagDefinition({ closedByChildren: ['tbody'], closedByParent: true }), |
| 'tr': new HtmlTagDefinition({ closedByChildren: ['tr'], closedByParent: true }), |
| 'td': new HtmlTagDefinition({ closedByChildren: ['td', 'th'], closedByParent: true }), |
| 'th': new HtmlTagDefinition({ closedByChildren: ['td', 'th'], closedByParent: true }), |
| 'col': new HtmlTagDefinition({ isVoid: true }), |
| 'svg': new HtmlTagDefinition({ implicitNamespacePrefix: 'svg' }), |
| 'math': new HtmlTagDefinition({ implicitNamespacePrefix: 'math' }), |
| 'li': new HtmlTagDefinition({ closedByChildren: ['li'], closedByParent: true }), |
| 'dt': new HtmlTagDefinition({ closedByChildren: ['dt', 'dd'] }), |
| 'dd': new HtmlTagDefinition({ closedByChildren: ['dt', 'dd'], closedByParent: true }), |
| 'rb': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }), |
| 'rt': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }), |
| 'rtc': new HtmlTagDefinition({ closedByChildren: ['rb', 'rtc', 'rp'], closedByParent: true }), |
| 'rp': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }), |
| 'optgroup': new HtmlTagDefinition({ closedByChildren: ['optgroup'], closedByParent: true }), |
| 'option': new HtmlTagDefinition({ closedByChildren: ['option', 'optgroup'], closedByParent: true }), |
| 'pre': new HtmlTagDefinition({ ignoreFirstLf: true }), |
| 'listing': new HtmlTagDefinition({ ignoreFirstLf: true }), |
| 'style': new HtmlTagDefinition({ contentType: exports.TagContentType.RAW_TEXT }), |
| 'script': new HtmlTagDefinition({ contentType: exports.TagContentType.RAW_TEXT }), |
| 'title': new HtmlTagDefinition({ contentType: exports.TagContentType.ESCAPABLE_RAW_TEXT }), |
| 'textarea': new HtmlTagDefinition({ contentType: exports.TagContentType.ESCAPABLE_RAW_TEXT, ignoreFirstLf: true }), |
| }; |
| } |
| return TAG_DEFINITIONS[tagName.toLowerCase()] || _DEFAULT_TAG_DEFINITION; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var _SELECTOR_REGEXP = new RegExp('(\\:not\\()|' + //":not(" |
| '([-\\w]+)|' + // "tag" |
| '(?:\\.([-\\w]+))|' + // ".class" |
| // "-" should appear first in the regexp below as FF31 parses "[.-\w]" as a range |
| '(?:\\[([-.\\w*]+)(?:=([\"\']?)([^\\]\"\']*)\\5)?\\])|' + // "[name]", "[name=value]", |
| // "[name="value"]", |
| // "[name='value']" |
| '(\\))|' + // ")" |
| '(\\s*,\\s*)', // "," |
| 'g'); |
| /** |
| * A css selector contains an element name, |
| * css classes and attribute/value pairs with the purpose |
| * of selecting subsets out of them. |
| */ |
| var CssSelector = /** @class */ (function () { |
| function CssSelector() { |
| this.element = null; |
| this.classNames = []; |
| /** |
| * The selectors are encoded in pairs where: |
| * - even locations are attribute names |
| * - odd locations are attribute values. |
| * |
| * Example: |
| * Selector: `[key1=value1][key2]` would parse to: |
| * ``` |
| * ['key1', 'value1', 'key2', ''] |
| * ``` |
| */ |
| this.attrs = []; |
| this.notSelectors = []; |
| } |
| CssSelector.parse = function (selector) { |
| var results = []; |
| var _addResult = function (res, cssSel) { |
| if (cssSel.notSelectors.length > 0 && !cssSel.element && cssSel.classNames.length == 0 && |
| cssSel.attrs.length == 0) { |
| cssSel.element = '*'; |
| } |
| res.push(cssSel); |
| }; |
| var cssSelector = new CssSelector(); |
| var match; |
| var current = cssSelector; |
| var inNot = false; |
| _SELECTOR_REGEXP.lastIndex = 0; |
| while (match = _SELECTOR_REGEXP.exec(selector)) { |
| if (match[1]) { |
| if (inNot) { |
| throw new Error('Nesting :not is not allowed in a selector'); |
| } |
| inNot = true; |
| current = new CssSelector(); |
| cssSelector.notSelectors.push(current); |
| } |
| if (match[2]) { |
| current.setElement(match[2]); |
| } |
| if (match[3]) { |
| current.addClassName(match[3]); |
| } |
| if (match[4]) { |
| current.addAttribute(match[4], match[6]); |
| } |
| if (match[7]) { |
| inNot = false; |
| current = cssSelector; |
| } |
| if (match[8]) { |
| if (inNot) { |
| throw new Error('Multiple selectors in :not are not supported'); |
| } |
| _addResult(results, cssSelector); |
| cssSelector = current = new CssSelector(); |
| } |
| } |
| _addResult(results, cssSelector); |
| return results; |
| }; |
| CssSelector.prototype.isElementSelector = function () { |
| return this.hasElementSelector() && this.classNames.length == 0 && this.attrs.length == 0 && |
| this.notSelectors.length === 0; |
| }; |
| CssSelector.prototype.hasElementSelector = function () { return !!this.element; }; |
| CssSelector.prototype.setElement = function (element) { |
| if (element === void 0) { element = null; } |
| this.element = element; |
| }; |
| /** Gets a template string for an element that matches the selector. */ |
| CssSelector.prototype.getMatchingElementTemplate = function () { |
| var tagName = this.element || 'div'; |
| var classAttr = this.classNames.length > 0 ? " class=\"" + this.classNames.join(' ') + "\"" : ''; |
| var attrs = ''; |
| for (var i = 0; i < this.attrs.length; i += 2) { |
| var attrName = this.attrs[i]; |
| var attrValue = this.attrs[i + 1] !== '' ? "=\"" + this.attrs[i + 1] + "\"" : ''; |
| attrs += " " + attrName + attrValue; |
| } |
| return getHtmlTagDefinition(tagName).isVoid ? "<" + tagName + classAttr + attrs + "/>" : |
| "<" + tagName + classAttr + attrs + "></" + tagName + ">"; |
| }; |
| CssSelector.prototype.getAttrs = function () { |
| var result = []; |
| if (this.classNames.length > 0) { |
| result.push('class', this.classNames.join(' ')); |
| } |
| return result.concat(this.attrs); |
| }; |
| CssSelector.prototype.addAttribute = function (name, value) { |
| if (value === void 0) { value = ''; } |
| this.attrs.push(name, value && value.toLowerCase() || ''); |
| }; |
| CssSelector.prototype.addClassName = function (name) { this.classNames.push(name.toLowerCase()); }; |
| CssSelector.prototype.toString = function () { |
| var res = this.element || ''; |
| if (this.classNames) { |
| this.classNames.forEach(function (klass) { return res += "." + klass; }); |
| } |
| if (this.attrs) { |
| for (var i = 0; i < this.attrs.length; i += 2) { |
| var name_1 = this.attrs[i]; |
| var value = this.attrs[i + 1]; |
| res += "[" + name_1 + (value ? '=' + value : '') + "]"; |
| } |
| } |
| this.notSelectors.forEach(function (notSelector) { return res += ":not(" + notSelector + ")"; }); |
| return res; |
| }; |
| return CssSelector; |
| }()); |
| /** |
| * Reads a list of CssSelectors and allows to calculate which ones |
| * are contained in a given CssSelector. |
| */ |
| var SelectorMatcher = /** @class */ (function () { |
| function SelectorMatcher() { |
| this._elementMap = new Map(); |
| this._elementPartialMap = new Map(); |
| this._classMap = new Map(); |
| this._classPartialMap = new Map(); |
| this._attrValueMap = new Map(); |
| this._attrValuePartialMap = new Map(); |
| this._listContexts = []; |
| } |
| SelectorMatcher.createNotMatcher = function (notSelectors) { |
| var notMatcher = new SelectorMatcher(); |
| notMatcher.addSelectables(notSelectors, null); |
| return notMatcher; |
| }; |
| SelectorMatcher.prototype.addSelectables = function (cssSelectors, callbackCtxt) { |
| var listContext = null; |
| if (cssSelectors.length > 1) { |
| listContext = new SelectorListContext(cssSelectors); |
| this._listContexts.push(listContext); |
| } |
| for (var i = 0; i < cssSelectors.length; i++) { |
| this._addSelectable(cssSelectors[i], callbackCtxt, listContext); |
| } |
| }; |
| /** |
| * Add an object that can be found later on by calling `match`. |
| * @param cssSelector A css selector |
| * @param callbackCtxt An opaque object that will be given to the callback of the `match` function |
| */ |
| SelectorMatcher.prototype._addSelectable = function (cssSelector, callbackCtxt, listContext) { |
| var matcher = this; |
| var element = cssSelector.element; |
| var classNames = cssSelector.classNames; |
| var attrs = cssSelector.attrs; |
| var selectable = new SelectorContext(cssSelector, callbackCtxt, listContext); |
| if (element) { |
| var isTerminal = attrs.length === 0 && classNames.length === 0; |
| if (isTerminal) { |
| this._addTerminal(matcher._elementMap, element, selectable); |
| } |
| else { |
| matcher = this._addPartial(matcher._elementPartialMap, element); |
| } |
| } |
| if (classNames) { |
| for (var i = 0; i < classNames.length; i++) { |
| var isTerminal = attrs.length === 0 && i === classNames.length - 1; |
| var className = classNames[i]; |
| if (isTerminal) { |
| this._addTerminal(matcher._classMap, className, selectable); |
| } |
| else { |
| matcher = this._addPartial(matcher._classPartialMap, className); |
| } |
| } |
| } |
| if (attrs) { |
| for (var i = 0; i < attrs.length; i += 2) { |
| var isTerminal = i === attrs.length - 2; |
| var name_2 = attrs[i]; |
| var value = attrs[i + 1]; |
| if (isTerminal) { |
| var terminalMap = matcher._attrValueMap; |
| var terminalValuesMap = terminalMap.get(name_2); |
| if (!terminalValuesMap) { |
| terminalValuesMap = new Map(); |
| terminalMap.set(name_2, terminalValuesMap); |
| } |
| this._addTerminal(terminalValuesMap, value, selectable); |
| } |
| else { |
| var partialMap = matcher._attrValuePartialMap; |
| var partialValuesMap = partialMap.get(name_2); |
| if (!partialValuesMap) { |
| partialValuesMap = new Map(); |
| partialMap.set(name_2, partialValuesMap); |
| } |
| matcher = this._addPartial(partialValuesMap, value); |
| } |
| } |
| } |
| }; |
| SelectorMatcher.prototype._addTerminal = function (map, name, selectable) { |
| var terminalList = map.get(name); |
| if (!terminalList) { |
| terminalList = []; |
| map.set(name, terminalList); |
| } |
| terminalList.push(selectable); |
| }; |
| SelectorMatcher.prototype._addPartial = function (map, name) { |
| var matcher = map.get(name); |
| if (!matcher) { |
| matcher = new SelectorMatcher(); |
| map.set(name, matcher); |
| } |
| return matcher; |
| }; |
| /** |
| * Find the objects that have been added via `addSelectable` |
| * whose css selector is contained in the given css selector. |
| * @param cssSelector A css selector |
| * @param matchedCallback This callback will be called with the object handed into `addSelectable` |
| * @return boolean true if a match was found |
| */ |
| SelectorMatcher.prototype.match = function (cssSelector, matchedCallback) { |
| var result = false; |
| var element = cssSelector.element; |
| var classNames = cssSelector.classNames; |
| var attrs = cssSelector.attrs; |
| for (var i = 0; i < this._listContexts.length; i++) { |
| this._listContexts[i].alreadyMatched = false; |
| } |
| result = this._matchTerminal(this._elementMap, element, cssSelector, matchedCallback) || result; |
| result = this._matchPartial(this._elementPartialMap, element, cssSelector, matchedCallback) || |
| result; |
| if (classNames) { |
| for (var i = 0; i < classNames.length; i++) { |
| var className = classNames[i]; |
| result = |
| this._matchTerminal(this._classMap, className, cssSelector, matchedCallback) || result; |
| result = |
| this._matchPartial(this._classPartialMap, className, cssSelector, matchedCallback) || |
| result; |
| } |
| } |
| if (attrs) { |
| for (var i = 0; i < attrs.length; i += 2) { |
| var name_3 = attrs[i]; |
| var value = attrs[i + 1]; |
| var terminalValuesMap = this._attrValueMap.get(name_3); |
| if (value) { |
| result = |
| this._matchTerminal(terminalValuesMap, '', cssSelector, matchedCallback) || result; |
| } |
| result = |
| this._matchTerminal(terminalValuesMap, value, cssSelector, matchedCallback) || result; |
| var partialValuesMap = this._attrValuePartialMap.get(name_3); |
| if (value) { |
| result = this._matchPartial(partialValuesMap, '', cssSelector, matchedCallback) || result; |
| } |
| result = |
| this._matchPartial(partialValuesMap, value, cssSelector, matchedCallback) || result; |
| } |
| } |
| return result; |
| }; |
| /** @internal */ |
| SelectorMatcher.prototype._matchTerminal = function (map, name, cssSelector, matchedCallback) { |
| if (!map || typeof name !== 'string') { |
| return false; |
| } |
| var selectables = map.get(name) || []; |
| var starSelectables = map.get('*'); |
| if (starSelectables) { |
| selectables = selectables.concat(starSelectables); |
| } |
| if (selectables.length === 0) { |
| return false; |
| } |
| var selectable; |
| var result = false; |
| for (var i = 0; i < selectables.length; i++) { |
| selectable = selectables[i]; |
| result = selectable.finalize(cssSelector, matchedCallback) || result; |
| } |
| return result; |
| }; |
| /** @internal */ |
| SelectorMatcher.prototype._matchPartial = function (map, name, cssSelector, matchedCallback) { |
| if (!map || typeof name !== 'string') { |
| return false; |
| } |
| var nestedSelector = map.get(name); |
| if (!nestedSelector) { |
| return false; |
| } |
| // TODO(perf): get rid of recursion and measure again |
| // TODO(perf): don't pass the whole selector into the recursion, |
| // but only the not processed parts |
| return nestedSelector.match(cssSelector, matchedCallback); |
| }; |
| return SelectorMatcher; |
| }()); |
| var SelectorListContext = /** @class */ (function () { |
| function SelectorListContext(selectors) { |
| this.selectors = selectors; |
| this.alreadyMatched = false; |
| } |
| return SelectorListContext; |
| }()); |
| // Store context to pass back selector and context when a selector is matched |
| var SelectorContext = /** @class */ (function () { |
| function SelectorContext(selector, cbContext, listContext) { |
| this.selector = selector; |
| this.cbContext = cbContext; |
| this.listContext = listContext; |
| this.notSelectors = selector.notSelectors; |
| } |
| SelectorContext.prototype.finalize = function (cssSelector, callback) { |
| var result = true; |
| if (this.notSelectors.length > 0 && (!this.listContext || !this.listContext.alreadyMatched)) { |
| var notMatcher = SelectorMatcher.createNotMatcher(this.notSelectors); |
| result = !notMatcher.match(cssSelector, null); |
| } |
| if (result && callback && (!this.listContext || !this.listContext.alreadyMatched)) { |
| if (this.listContext) { |
| this.listContext.alreadyMatched = true; |
| } |
| callback(this.selector, this.cbContext); |
| } |
| return result; |
| }; |
| return SelectorContext; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var createInject = makeMetadataFactory('Inject', function (token) { return ({ token: token }); }); |
| var createInjectionToken = makeMetadataFactory('InjectionToken', function (desc) { return ({ _desc: desc, ngInjectableDef: undefined }); }); |
| var createAttribute = makeMetadataFactory('Attribute', function (attributeName) { return ({ attributeName: attributeName }); }); |
| var createContentChildren = makeMetadataFactory('ContentChildren', function (selector, data) { |
| if (data === void 0) { data = {}; } |
| return (__assign({ selector: selector, first: false, isViewQuery: false, descendants: false }, data)); |
| }); |
| var createContentChild = makeMetadataFactory('ContentChild', function (selector, data) { |
| if (data === void 0) { data = {}; } |
| return (__assign({ selector: selector, first: true, isViewQuery: false, descendants: true }, data)); |
| }); |
| var createViewChildren = makeMetadataFactory('ViewChildren', function (selector, data) { |
| if (data === void 0) { data = {}; } |
| return (__assign({ selector: selector, first: false, isViewQuery: true, descendants: true }, data)); |
| }); |
| var createViewChild = makeMetadataFactory('ViewChild', function (selector, data) { |
| return (__assign({ selector: selector, first: true, isViewQuery: true, descendants: true }, data)); |
| }); |
| var createDirective = makeMetadataFactory('Directive', function (dir) { |
| if (dir === void 0) { dir = {}; } |
| return dir; |
| }); |
| var ViewEncapsulation; |
| (function (ViewEncapsulation) { |
| ViewEncapsulation[ViewEncapsulation["Emulated"] = 0] = "Emulated"; |
| ViewEncapsulation[ViewEncapsulation["Native"] = 1] = "Native"; |
| ViewEncapsulation[ViewEncapsulation["None"] = 2] = "None"; |
| ViewEncapsulation[ViewEncapsulation["ShadowDom"] = 3] = "ShadowDom"; |
| })(ViewEncapsulation || (ViewEncapsulation = {})); |
| var ChangeDetectionStrategy; |
| (function (ChangeDetectionStrategy) { |
| ChangeDetectionStrategy[ChangeDetectionStrategy["OnPush"] = 0] = "OnPush"; |
| ChangeDetectionStrategy[ChangeDetectionStrategy["Default"] = 1] = "Default"; |
| })(ChangeDetectionStrategy || (ChangeDetectionStrategy = {})); |
| var createComponent = makeMetadataFactory('Component', function (c) { |
| if (c === void 0) { c = {}; } |
| return (__assign({ changeDetection: ChangeDetectionStrategy.Default }, c)); |
| }); |
| var createPipe = makeMetadataFactory('Pipe', function (p) { return (__assign({ pure: true }, p)); }); |
| var createInput = makeMetadataFactory('Input', function (bindingPropertyName) { return ({ bindingPropertyName: bindingPropertyName }); }); |
| var createOutput = makeMetadataFactory('Output', function (bindingPropertyName) { return ({ bindingPropertyName: bindingPropertyName }); }); |
| var createHostBinding = makeMetadataFactory('HostBinding', function (hostPropertyName) { return ({ hostPropertyName: hostPropertyName }); }); |
| var createHostListener = makeMetadataFactory('HostListener', function (eventName, args) { return ({ eventName: eventName, args: args }); }); |
| var createNgModule = makeMetadataFactory('NgModule', function (ngModule) { return ngModule; }); |
| var createInjectable = makeMetadataFactory('Injectable', function (injectable) { |
| if (injectable === void 0) { injectable = {}; } |
| return injectable; |
| }); |
| var CUSTOM_ELEMENTS_SCHEMA = { |
| name: 'custom-elements' |
| }; |
| var NO_ERRORS_SCHEMA = { |
| name: 'no-errors-schema' |
| }; |
| var createOptional = makeMetadataFactory('Optional'); |
| var createSelf = makeMetadataFactory('Self'); |
| var createSkipSelf = makeMetadataFactory('SkipSelf'); |
| var createHost = makeMetadataFactory('Host'); |
| var Type = Function; |
| var SecurityContext; |
| (function (SecurityContext) { |
| SecurityContext[SecurityContext["NONE"] = 0] = "NONE"; |
| SecurityContext[SecurityContext["HTML"] = 1] = "HTML"; |
| SecurityContext[SecurityContext["STYLE"] = 2] = "STYLE"; |
| SecurityContext[SecurityContext["SCRIPT"] = 3] = "SCRIPT"; |
| SecurityContext[SecurityContext["URL"] = 4] = "URL"; |
| SecurityContext[SecurityContext["RESOURCE_URL"] = 5] = "RESOURCE_URL"; |
| })(SecurityContext || (SecurityContext = {})); |
| var MissingTranslationStrategy; |
| (function (MissingTranslationStrategy) { |
| MissingTranslationStrategy[MissingTranslationStrategy["Error"] = 0] = "Error"; |
| MissingTranslationStrategy[MissingTranslationStrategy["Warning"] = 1] = "Warning"; |
| MissingTranslationStrategy[MissingTranslationStrategy["Ignore"] = 2] = "Ignore"; |
| })(MissingTranslationStrategy || (MissingTranslationStrategy = {})); |
| function makeMetadataFactory(name, props) { |
| // This must be declared as a function, not a fat arrow, so that ES2015 devmode produces code |
| // that works with the static_reflector.ts in the ViewEngine compiler. |
| // In particular, `_registerDecoratorOrConstructor` assumes that the value returned here can be |
| // new'ed. |
| function factory() { |
| var args = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| args[_i] = arguments[_i]; |
| } |
| var values = props ? props.apply(void 0, __spread(args)) : {}; |
| return __assign({ ngMetadataName: name }, values); |
| } |
| factory.isTypeOf = function (obj) { return obj && obj.ngMetadataName === name; }; |
| factory.ngMetadataName = name; |
| return factory; |
| } |
| function parserSelectorToSimpleSelector(selector) { |
| var classes = selector.classNames && selector.classNames.length ? __spread([8 /* CLASS */], selector.classNames) : |
| []; |
| var elementName = selector.element && selector.element !== '*' ? selector.element : ''; |
| return __spread([elementName], selector.attrs, classes); |
| } |
| function parserSelectorToNegativeSelector(selector) { |
| var classes = selector.classNames && selector.classNames.length ? __spread([8 /* CLASS */], selector.classNames) : |
| []; |
| if (selector.element) { |
| return __spread([ |
| 1 /* NOT */ | 4 /* ELEMENT */, selector.element |
| ], selector.attrs, classes); |
| } |
| else if (selector.attrs.length) { |
| return __spread([1 /* NOT */ | 2 /* ATTRIBUTE */], selector.attrs, classes); |
| } |
| else { |
| return selector.classNames && selector.classNames.length ? __spread([1 /* NOT */ | 8 /* CLASS */], selector.classNames) : |
| []; |
| } |
| } |
| function parserSelectorToR3Selector(selector) { |
| var positive = parserSelectorToSimpleSelector(selector); |
| var negative = selector.notSelectors && selector.notSelectors.length ? |
| selector.notSelectors.map(function (notSelector) { return parserSelectorToNegativeSelector(notSelector); }) : |
| []; |
| return positive.concat.apply(positive, __spread(negative)); |
| } |
| function parseSelectorToR3Selector(selector) { |
| return selector ? CssSelector.parse(selector).map(parserSelectorToR3Selector) : []; |
| } |
| |
| var core = /*#__PURE__*/Object.freeze({ |
| createInject: createInject, |
| createInjectionToken: createInjectionToken, |
| createAttribute: createAttribute, |
| createContentChildren: createContentChildren, |
| createContentChild: createContentChild, |
| createViewChildren: createViewChildren, |
| createViewChild: createViewChild, |
| createDirective: createDirective, |
| get ViewEncapsulation () { return ViewEncapsulation; }, |
| get ChangeDetectionStrategy () { return ChangeDetectionStrategy; }, |
| createComponent: createComponent, |
| createPipe: createPipe, |
| createInput: createInput, |
| createOutput: createOutput, |
| createHostBinding: createHostBinding, |
| createHostListener: createHostListener, |
| createNgModule: createNgModule, |
| createInjectable: createInjectable, |
| CUSTOM_ELEMENTS_SCHEMA: CUSTOM_ELEMENTS_SCHEMA, |
| NO_ERRORS_SCHEMA: NO_ERRORS_SCHEMA, |
| createOptional: createOptional, |
| createSelf: createSelf, |
| createSkipSelf: createSkipSelf, |
| createHost: createHost, |
| Type: Type, |
| get SecurityContext () { return SecurityContext; }, |
| get MissingTranslationStrategy () { return MissingTranslationStrategy; }, |
| parseSelectorToR3Selector: parseSelectorToR3Selector |
| }); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| //// Types |
| var TypeModifier; |
| (function (TypeModifier) { |
| TypeModifier[TypeModifier["Const"] = 0] = "Const"; |
| })(TypeModifier || (TypeModifier = {})); |
| var Type$1 = /** @class */ (function () { |
| function Type(modifiers) { |
| if (modifiers === void 0) { modifiers = null; } |
| this.modifiers = modifiers; |
| if (!modifiers) { |
| this.modifiers = []; |
| } |
| } |
| Type.prototype.hasModifier = function (modifier) { return this.modifiers.indexOf(modifier) !== -1; }; |
| return Type; |
| }()); |
| (function (BuiltinTypeName) { |
| BuiltinTypeName[BuiltinTypeName["Dynamic"] = 0] = "Dynamic"; |
| BuiltinTypeName[BuiltinTypeName["Bool"] = 1] = "Bool"; |
| BuiltinTypeName[BuiltinTypeName["String"] = 2] = "String"; |
| BuiltinTypeName[BuiltinTypeName["Int"] = 3] = "Int"; |
| BuiltinTypeName[BuiltinTypeName["Number"] = 4] = "Number"; |
| BuiltinTypeName[BuiltinTypeName["Function"] = 5] = "Function"; |
| BuiltinTypeName[BuiltinTypeName["Inferred"] = 6] = "Inferred"; |
| BuiltinTypeName[BuiltinTypeName["None"] = 7] = "None"; |
| })(exports.BuiltinTypeName || (exports.BuiltinTypeName = {})); |
| var BuiltinType = /** @class */ (function (_super) { |
| __extends(BuiltinType, _super); |
| function BuiltinType(name, modifiers) { |
| if (modifiers === void 0) { modifiers = null; } |
| var _this = _super.call(this, modifiers) || this; |
| _this.name = name; |
| return _this; |
| } |
| BuiltinType.prototype.visitType = function (visitor, context) { |
| return visitor.visitBuiltinType(this, context); |
| }; |
| return BuiltinType; |
| }(Type$1)); |
| var ExpressionType = /** @class */ (function (_super) { |
| __extends(ExpressionType, _super); |
| function ExpressionType(value, modifiers, typeParams) { |
| if (modifiers === void 0) { modifiers = null; } |
| if (typeParams === void 0) { typeParams = null; } |
| var _this = _super.call(this, modifiers) || this; |
| _this.value = value; |
| _this.typeParams = typeParams; |
| return _this; |
| } |
| ExpressionType.prototype.visitType = function (visitor, context) { |
| return visitor.visitExpressionType(this, context); |
| }; |
| return ExpressionType; |
| }(Type$1)); |
| var ArrayType = /** @class */ (function (_super) { |
| __extends(ArrayType, _super); |
| function ArrayType(of, modifiers) { |
| if (modifiers === void 0) { modifiers = null; } |
| var _this = _super.call(this, modifiers) || this; |
| _this.of = of; |
| return _this; |
| } |
| ArrayType.prototype.visitType = function (visitor, context) { |
| return visitor.visitArrayType(this, context); |
| }; |
| return ArrayType; |
| }(Type$1)); |
| var MapType = /** @class */ (function (_super) { |
| __extends(MapType, _super); |
| function MapType(valueType, modifiers) { |
| if (modifiers === void 0) { modifiers = null; } |
| var _this = _super.call(this, modifiers) || this; |
| _this.valueType = valueType || null; |
| return _this; |
| } |
| MapType.prototype.visitType = function (visitor, context) { return visitor.visitMapType(this, context); }; |
| return MapType; |
| }(Type$1)); |
| var DYNAMIC_TYPE = new BuiltinType(exports.BuiltinTypeName.Dynamic); |
| var INFERRED_TYPE = new BuiltinType(exports.BuiltinTypeName.Inferred); |
| var BOOL_TYPE = new BuiltinType(exports.BuiltinTypeName.Bool); |
| var INT_TYPE = new BuiltinType(exports.BuiltinTypeName.Int); |
| var NUMBER_TYPE = new BuiltinType(exports.BuiltinTypeName.Number); |
| var STRING_TYPE = new BuiltinType(exports.BuiltinTypeName.String); |
| var FUNCTION_TYPE = new BuiltinType(exports.BuiltinTypeName.Function); |
| var NONE_TYPE = new BuiltinType(exports.BuiltinTypeName.None); |
| (function (BinaryOperator) { |
| BinaryOperator[BinaryOperator["Equals"] = 0] = "Equals"; |
| BinaryOperator[BinaryOperator["NotEquals"] = 1] = "NotEquals"; |
| BinaryOperator[BinaryOperator["Identical"] = 2] = "Identical"; |
| BinaryOperator[BinaryOperator["NotIdentical"] = 3] = "NotIdentical"; |
| BinaryOperator[BinaryOperator["Minus"] = 4] = "Minus"; |
| BinaryOperator[BinaryOperator["Plus"] = 5] = "Plus"; |
| BinaryOperator[BinaryOperator["Divide"] = 6] = "Divide"; |
| BinaryOperator[BinaryOperator["Multiply"] = 7] = "Multiply"; |
| BinaryOperator[BinaryOperator["Modulo"] = 8] = "Modulo"; |
| BinaryOperator[BinaryOperator["And"] = 9] = "And"; |
| BinaryOperator[BinaryOperator["Or"] = 10] = "Or"; |
| BinaryOperator[BinaryOperator["BitwiseAnd"] = 11] = "BitwiseAnd"; |
| BinaryOperator[BinaryOperator["Lower"] = 12] = "Lower"; |
| BinaryOperator[BinaryOperator["LowerEquals"] = 13] = "LowerEquals"; |
| BinaryOperator[BinaryOperator["Bigger"] = 14] = "Bigger"; |
| BinaryOperator[BinaryOperator["BiggerEquals"] = 15] = "BiggerEquals"; |
| })(exports.BinaryOperator || (exports.BinaryOperator = {})); |
| function nullSafeIsEquivalent(base, other) { |
| if (base == null || other == null) { |
| return base == other; |
| } |
| return base.isEquivalent(other); |
| } |
| function areAllEquivalent(base, other) { |
| var len = base.length; |
| if (len !== other.length) { |
| return false; |
| } |
| for (var i = 0; i < len; i++) { |
| if (!base[i].isEquivalent(other[i])) { |
| return false; |
| } |
| } |
| return true; |
| } |
| var Expression = /** @class */ (function () { |
| function Expression(type, sourceSpan) { |
| this.type = type || null; |
| this.sourceSpan = sourceSpan || null; |
| } |
| Expression.prototype.prop = function (name, sourceSpan) { |
| return new ReadPropExpr(this, name, null, sourceSpan); |
| }; |
| Expression.prototype.key = function (index, type, sourceSpan) { |
| return new ReadKeyExpr(this, index, type, sourceSpan); |
| }; |
| Expression.prototype.callMethod = function (name, params, sourceSpan) { |
| return new InvokeMethodExpr(this, name, params, null, sourceSpan); |
| }; |
| Expression.prototype.callFn = function (params, sourceSpan) { |
| return new InvokeFunctionExpr(this, params, null, sourceSpan); |
| }; |
| Expression.prototype.instantiate = function (params, type, sourceSpan) { |
| return new InstantiateExpr(this, params, type, sourceSpan); |
| }; |
| Expression.prototype.conditional = function (trueCase, falseCase, sourceSpan) { |
| if (falseCase === void 0) { falseCase = null; } |
| return new ConditionalExpr(this, trueCase, falseCase, null, sourceSpan); |
| }; |
| Expression.prototype.equals = function (rhs, sourceSpan) { |
| return new BinaryOperatorExpr(exports.BinaryOperator.Equals, this, rhs, null, sourceSpan); |
| }; |
| Expression.prototype.notEquals = function (rhs, sourceSpan) { |
| return new BinaryOperatorExpr(exports.BinaryOperator.NotEquals, this, rhs, null, sourceSpan); |
| }; |
| Expression.prototype.identical = function (rhs, sourceSpan) { |
| return new BinaryOperatorExpr(exports.BinaryOperator.Identical, this, rhs, null, sourceSpan); |
| }; |
| Expression.prototype.notIdentical = function (rhs, sourceSpan) { |
| return new BinaryOperatorExpr(exports.BinaryOperator.NotIdentical, this, rhs, null, sourceSpan); |
| }; |
| Expression.prototype.minus = function (rhs, sourceSpan) { |
| return new BinaryOperatorExpr(exports.BinaryOperator.Minus, this, rhs, null, sourceSpan); |
| }; |
| Expression.prototype.plus = function (rhs, sourceSpan) { |
| return new BinaryOperatorExpr(exports.BinaryOperator.Plus, this, rhs, null, sourceSpan); |
| }; |
| Expression.prototype.divide = function (rhs, sourceSpan) { |
| return new BinaryOperatorExpr(exports.BinaryOperator.Divide, this, rhs, null, sourceSpan); |
| }; |
| Expression.prototype.multiply = function (rhs, sourceSpan) { |
| return new BinaryOperatorExpr(exports.BinaryOperator.Multiply, this, rhs, null, sourceSpan); |
| }; |
| Expression.prototype.modulo = function (rhs, sourceSpan) { |
| return new BinaryOperatorExpr(exports.BinaryOperator.Modulo, this, rhs, null, sourceSpan); |
| }; |
| Expression.prototype.and = function (rhs, sourceSpan) { |
| return new BinaryOperatorExpr(exports.BinaryOperator.And, this, rhs, null, sourceSpan); |
| }; |
| Expression.prototype.bitwiseAnd = function (rhs, sourceSpan, parens) { |
| if (parens === void 0) { parens = true; } |
| return new BinaryOperatorExpr(exports.BinaryOperator.BitwiseAnd, this, rhs, null, sourceSpan, parens); |
| }; |
| Expression.prototype.or = function (rhs, sourceSpan) { |
| return new BinaryOperatorExpr(exports.BinaryOperator.Or, this, rhs, null, sourceSpan); |
| }; |
| Expression.prototype.lower = function (rhs, sourceSpan) { |
| return new BinaryOperatorExpr(exports.BinaryOperator.Lower, this, rhs, null, sourceSpan); |
| }; |
| Expression.prototype.lowerEquals = function (rhs, sourceSpan) { |
| return new BinaryOperatorExpr(exports.BinaryOperator.LowerEquals, this, rhs, null, sourceSpan); |
| }; |
| Expression.prototype.bigger = function (rhs, sourceSpan) { |
| return new BinaryOperatorExpr(exports.BinaryOperator.Bigger, this, rhs, null, sourceSpan); |
| }; |
| Expression.prototype.biggerEquals = function (rhs, sourceSpan) { |
| return new BinaryOperatorExpr(exports.BinaryOperator.BiggerEquals, this, rhs, null, sourceSpan); |
| }; |
| Expression.prototype.isBlank = function (sourceSpan) { |
| // Note: We use equals by purpose here to compare to null and undefined in JS. |
| // We use the typed null to allow strictNullChecks to narrow types. |
| return this.equals(TYPED_NULL_EXPR, sourceSpan); |
| }; |
| Expression.prototype.cast = function (type, sourceSpan) { |
| return new CastExpr(this, type, sourceSpan); |
| }; |
| Expression.prototype.toStmt = function () { return new ExpressionStatement(this, null); }; |
| return Expression; |
| }()); |
| (function (BuiltinVar) { |
| BuiltinVar[BuiltinVar["This"] = 0] = "This"; |
| BuiltinVar[BuiltinVar["Super"] = 1] = "Super"; |
| BuiltinVar[BuiltinVar["CatchError"] = 2] = "CatchError"; |
| BuiltinVar[BuiltinVar["CatchStack"] = 3] = "CatchStack"; |
| })(exports.BuiltinVar || (exports.BuiltinVar = {})); |
| var ReadVarExpr = /** @class */ (function (_super) { |
| __extends(ReadVarExpr, _super); |
| function ReadVarExpr(name, type, sourceSpan) { |
| var _this = _super.call(this, type, sourceSpan) || this; |
| if (typeof name === 'string') { |
| _this.name = name; |
| _this.builtin = null; |
| } |
| else { |
| _this.name = null; |
| _this.builtin = name; |
| } |
| return _this; |
| } |
| ReadVarExpr.prototype.isEquivalent = function (e) { |
| return e instanceof ReadVarExpr && this.name === e.name && this.builtin === e.builtin; |
| }; |
| ReadVarExpr.prototype.isConstant = function () { return false; }; |
| ReadVarExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitReadVarExpr(this, context); |
| }; |
| ReadVarExpr.prototype.set = function (value) { |
| if (!this.name) { |
| throw new Error("Built in variable " + this.builtin + " can not be assigned to."); |
| } |
| return new WriteVarExpr(this.name, value, null, this.sourceSpan); |
| }; |
| return ReadVarExpr; |
| }(Expression)); |
| var TypeofExpr = /** @class */ (function (_super) { |
| __extends(TypeofExpr, _super); |
| function TypeofExpr(expr, type, sourceSpan) { |
| var _this = _super.call(this, type, sourceSpan) || this; |
| _this.expr = expr; |
| return _this; |
| } |
| TypeofExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitTypeofExpr(this, context); |
| }; |
| TypeofExpr.prototype.isEquivalent = function (e) { |
| return e instanceof TypeofExpr && e.expr.isEquivalent(this.expr); |
| }; |
| TypeofExpr.prototype.isConstant = function () { return this.expr.isConstant(); }; |
| return TypeofExpr; |
| }(Expression)); |
| var WrappedNodeExpr = /** @class */ (function (_super) { |
| __extends(WrappedNodeExpr, _super); |
| function WrappedNodeExpr(node, type, sourceSpan) { |
| var _this = _super.call(this, type, sourceSpan) || this; |
| _this.node = node; |
| return _this; |
| } |
| WrappedNodeExpr.prototype.isEquivalent = function (e) { |
| return e instanceof WrappedNodeExpr && this.node === e.node; |
| }; |
| WrappedNodeExpr.prototype.isConstant = function () { return false; }; |
| WrappedNodeExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitWrappedNodeExpr(this, context); |
| }; |
| return WrappedNodeExpr; |
| }(Expression)); |
| var WriteVarExpr = /** @class */ (function (_super) { |
| __extends(WriteVarExpr, _super); |
| function WriteVarExpr(name, value, type, sourceSpan) { |
| var _this = _super.call(this, type || value.type, sourceSpan) || this; |
| _this.name = name; |
| _this.value = value; |
| return _this; |
| } |
| WriteVarExpr.prototype.isEquivalent = function (e) { |
| return e instanceof WriteVarExpr && this.name === e.name && this.value.isEquivalent(e.value); |
| }; |
| WriteVarExpr.prototype.isConstant = function () { return false; }; |
| WriteVarExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitWriteVarExpr(this, context); |
| }; |
| WriteVarExpr.prototype.toDeclStmt = function (type, modifiers) { |
| return new DeclareVarStmt(this.name, this.value, type, modifiers, this.sourceSpan); |
| }; |
| WriteVarExpr.prototype.toConstDecl = function () { return this.toDeclStmt(INFERRED_TYPE, [exports.StmtModifier.Final]); }; |
| return WriteVarExpr; |
| }(Expression)); |
| var WriteKeyExpr = /** @class */ (function (_super) { |
| __extends(WriteKeyExpr, _super); |
| function WriteKeyExpr(receiver, index, value, type, sourceSpan) { |
| var _this = _super.call(this, type || value.type, sourceSpan) || this; |
| _this.receiver = receiver; |
| _this.index = index; |
| _this.value = value; |
| return _this; |
| } |
| WriteKeyExpr.prototype.isEquivalent = function (e) { |
| return e instanceof WriteKeyExpr && this.receiver.isEquivalent(e.receiver) && |
| this.index.isEquivalent(e.index) && this.value.isEquivalent(e.value); |
| }; |
| WriteKeyExpr.prototype.isConstant = function () { return false; }; |
| WriteKeyExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitWriteKeyExpr(this, context); |
| }; |
| return WriteKeyExpr; |
| }(Expression)); |
| var WritePropExpr = /** @class */ (function (_super) { |
| __extends(WritePropExpr, _super); |
| function WritePropExpr(receiver, name, value, type, sourceSpan) { |
| var _this = _super.call(this, type || value.type, sourceSpan) || this; |
| _this.receiver = receiver; |
| _this.name = name; |
| _this.value = value; |
| return _this; |
| } |
| WritePropExpr.prototype.isEquivalent = function (e) { |
| return e instanceof WritePropExpr && this.receiver.isEquivalent(e.receiver) && |
| this.name === e.name && this.value.isEquivalent(e.value); |
| }; |
| WritePropExpr.prototype.isConstant = function () { return false; }; |
| WritePropExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitWritePropExpr(this, context); |
| }; |
| return WritePropExpr; |
| }(Expression)); |
| (function (BuiltinMethod) { |
| BuiltinMethod[BuiltinMethod["ConcatArray"] = 0] = "ConcatArray"; |
| BuiltinMethod[BuiltinMethod["SubscribeObservable"] = 1] = "SubscribeObservable"; |
| BuiltinMethod[BuiltinMethod["Bind"] = 2] = "Bind"; |
| })(exports.BuiltinMethod || (exports.BuiltinMethod = {})); |
| var InvokeMethodExpr = /** @class */ (function (_super) { |
| __extends(InvokeMethodExpr, _super); |
| function InvokeMethodExpr(receiver, method, args, type, sourceSpan) { |
| var _this = _super.call(this, type, sourceSpan) || this; |
| _this.receiver = receiver; |
| _this.args = args; |
| if (typeof method === 'string') { |
| _this.name = method; |
| _this.builtin = null; |
| } |
| else { |
| _this.name = null; |
| _this.builtin = method; |
| } |
| return _this; |
| } |
| InvokeMethodExpr.prototype.isEquivalent = function (e) { |
| return e instanceof InvokeMethodExpr && this.receiver.isEquivalent(e.receiver) && |
| this.name === e.name && this.builtin === e.builtin && areAllEquivalent(this.args, e.args); |
| }; |
| InvokeMethodExpr.prototype.isConstant = function () { return false; }; |
| InvokeMethodExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitInvokeMethodExpr(this, context); |
| }; |
| return InvokeMethodExpr; |
| }(Expression)); |
| var InvokeFunctionExpr = /** @class */ (function (_super) { |
| __extends(InvokeFunctionExpr, _super); |
| function InvokeFunctionExpr(fn, args, type, sourceSpan, pure) { |
| if (pure === void 0) { pure = false; } |
| var _this = _super.call(this, type, sourceSpan) || this; |
| _this.fn = fn; |
| _this.args = args; |
| _this.pure = pure; |
| return _this; |
| } |
| InvokeFunctionExpr.prototype.isEquivalent = function (e) { |
| return e instanceof InvokeFunctionExpr && this.fn.isEquivalent(e.fn) && |
| areAllEquivalent(this.args, e.args) && this.pure === e.pure; |
| }; |
| InvokeFunctionExpr.prototype.isConstant = function () { return false; }; |
| InvokeFunctionExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitInvokeFunctionExpr(this, context); |
| }; |
| return InvokeFunctionExpr; |
| }(Expression)); |
| var InstantiateExpr = /** @class */ (function (_super) { |
| __extends(InstantiateExpr, _super); |
| function InstantiateExpr(classExpr, args, type, sourceSpan) { |
| var _this = _super.call(this, type, sourceSpan) || this; |
| _this.classExpr = classExpr; |
| _this.args = args; |
| return _this; |
| } |
| InstantiateExpr.prototype.isEquivalent = function (e) { |
| return e instanceof InstantiateExpr && this.classExpr.isEquivalent(e.classExpr) && |
| areAllEquivalent(this.args, e.args); |
| }; |
| InstantiateExpr.prototype.isConstant = function () { return false; }; |
| InstantiateExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitInstantiateExpr(this, context); |
| }; |
| return InstantiateExpr; |
| }(Expression)); |
| var LiteralExpr = /** @class */ (function (_super) { |
| __extends(LiteralExpr, _super); |
| function LiteralExpr(value, type, sourceSpan) { |
| var _this = _super.call(this, type, sourceSpan) || this; |
| _this.value = value; |
| return _this; |
| } |
| LiteralExpr.prototype.isEquivalent = function (e) { |
| return e instanceof LiteralExpr && this.value === e.value; |
| }; |
| LiteralExpr.prototype.isConstant = function () { return true; }; |
| LiteralExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitLiteralExpr(this, context); |
| }; |
| return LiteralExpr; |
| }(Expression)); |
| var ExternalExpr = /** @class */ (function (_super) { |
| __extends(ExternalExpr, _super); |
| function ExternalExpr(value, type, typeParams, sourceSpan) { |
| if (typeParams === void 0) { typeParams = null; } |
| var _this = _super.call(this, type, sourceSpan) || this; |
| _this.value = value; |
| _this.typeParams = typeParams; |
| return _this; |
| } |
| ExternalExpr.prototype.isEquivalent = function (e) { |
| return e instanceof ExternalExpr && this.value.name === e.value.name && |
| this.value.moduleName === e.value.moduleName && this.value.runtime === e.value.runtime; |
| }; |
| ExternalExpr.prototype.isConstant = function () { return false; }; |
| ExternalExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitExternalExpr(this, context); |
| }; |
| return ExternalExpr; |
| }(Expression)); |
| var ExternalReference = /** @class */ (function () { |
| function ExternalReference(moduleName, name, runtime) { |
| this.moduleName = moduleName; |
| this.name = name; |
| this.runtime = runtime; |
| } |
| return ExternalReference; |
| }()); |
| var ConditionalExpr = /** @class */ (function (_super) { |
| __extends(ConditionalExpr, _super); |
| function ConditionalExpr(condition, trueCase, falseCase, type, sourceSpan) { |
| if (falseCase === void 0) { falseCase = null; } |
| var _this = _super.call(this, type || trueCase.type, sourceSpan) || this; |
| _this.condition = condition; |
| _this.falseCase = falseCase; |
| _this.trueCase = trueCase; |
| return _this; |
| } |
| ConditionalExpr.prototype.isEquivalent = function (e) { |
| return e instanceof ConditionalExpr && this.condition.isEquivalent(e.condition) && |
| this.trueCase.isEquivalent(e.trueCase) && nullSafeIsEquivalent(this.falseCase, e.falseCase); |
| }; |
| ConditionalExpr.prototype.isConstant = function () { return false; }; |
| ConditionalExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitConditionalExpr(this, context); |
| }; |
| return ConditionalExpr; |
| }(Expression)); |
| var NotExpr = /** @class */ (function (_super) { |
| __extends(NotExpr, _super); |
| function NotExpr(condition, sourceSpan) { |
| var _this = _super.call(this, BOOL_TYPE, sourceSpan) || this; |
| _this.condition = condition; |
| return _this; |
| } |
| NotExpr.prototype.isEquivalent = function (e) { |
| return e instanceof NotExpr && this.condition.isEquivalent(e.condition); |
| }; |
| NotExpr.prototype.isConstant = function () { return false; }; |
| NotExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitNotExpr(this, context); |
| }; |
| return NotExpr; |
| }(Expression)); |
| var AssertNotNull = /** @class */ (function (_super) { |
| __extends(AssertNotNull, _super); |
| function AssertNotNull(condition, sourceSpan) { |
| var _this = _super.call(this, condition.type, sourceSpan) || this; |
| _this.condition = condition; |
| return _this; |
| } |
| AssertNotNull.prototype.isEquivalent = function (e) { |
| return e instanceof AssertNotNull && this.condition.isEquivalent(e.condition); |
| }; |
| AssertNotNull.prototype.isConstant = function () { return false; }; |
| AssertNotNull.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitAssertNotNullExpr(this, context); |
| }; |
| return AssertNotNull; |
| }(Expression)); |
| var CastExpr = /** @class */ (function (_super) { |
| __extends(CastExpr, _super); |
| function CastExpr(value, type, sourceSpan) { |
| var _this = _super.call(this, type, sourceSpan) || this; |
| _this.value = value; |
| return _this; |
| } |
| CastExpr.prototype.isEquivalent = function (e) { |
| return e instanceof CastExpr && this.value.isEquivalent(e.value); |
| }; |
| CastExpr.prototype.isConstant = function () { return false; }; |
| CastExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitCastExpr(this, context); |
| }; |
| return CastExpr; |
| }(Expression)); |
| var FnParam = /** @class */ (function () { |
| function FnParam(name, type) { |
| if (type === void 0) { type = null; } |
| this.name = name; |
| this.type = type; |
| } |
| FnParam.prototype.isEquivalent = function (param) { return this.name === param.name; }; |
| return FnParam; |
| }()); |
| var FunctionExpr = /** @class */ (function (_super) { |
| __extends(FunctionExpr, _super); |
| function FunctionExpr(params, statements, type, sourceSpan, name) { |
| var _this = _super.call(this, type, sourceSpan) || this; |
| _this.params = params; |
| _this.statements = statements; |
| _this.name = name; |
| return _this; |
| } |
| FunctionExpr.prototype.isEquivalent = function (e) { |
| return e instanceof FunctionExpr && areAllEquivalent(this.params, e.params) && |
| areAllEquivalent(this.statements, e.statements); |
| }; |
| FunctionExpr.prototype.isConstant = function () { return false; }; |
| FunctionExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitFunctionExpr(this, context); |
| }; |
| FunctionExpr.prototype.toDeclStmt = function (name, modifiers) { |
| if (modifiers === void 0) { modifiers = null; } |
| return new DeclareFunctionStmt(name, this.params, this.statements, this.type, modifiers, this.sourceSpan); |
| }; |
| return FunctionExpr; |
| }(Expression)); |
| var BinaryOperatorExpr = /** @class */ (function (_super) { |
| __extends(BinaryOperatorExpr, _super); |
| function BinaryOperatorExpr(operator, lhs, rhs, type, sourceSpan, parens) { |
| if (parens === void 0) { parens = true; } |
| var _this = _super.call(this, type || lhs.type, sourceSpan) || this; |
| _this.operator = operator; |
| _this.rhs = rhs; |
| _this.parens = parens; |
| _this.lhs = lhs; |
| return _this; |
| } |
| BinaryOperatorExpr.prototype.isEquivalent = function (e) { |
| return e instanceof BinaryOperatorExpr && this.operator === e.operator && |
| this.lhs.isEquivalent(e.lhs) && this.rhs.isEquivalent(e.rhs); |
| }; |
| BinaryOperatorExpr.prototype.isConstant = function () { return false; }; |
| BinaryOperatorExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitBinaryOperatorExpr(this, context); |
| }; |
| return BinaryOperatorExpr; |
| }(Expression)); |
| var ReadPropExpr = /** @class */ (function (_super) { |
| __extends(ReadPropExpr, _super); |
| function ReadPropExpr(receiver, name, type, sourceSpan) { |
| var _this = _super.call(this, type, sourceSpan) || this; |
| _this.receiver = receiver; |
| _this.name = name; |
| return _this; |
| } |
| ReadPropExpr.prototype.isEquivalent = function (e) { |
| return e instanceof ReadPropExpr && this.receiver.isEquivalent(e.receiver) && |
| this.name === e.name; |
| }; |
| ReadPropExpr.prototype.isConstant = function () { return false; }; |
| ReadPropExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitReadPropExpr(this, context); |
| }; |
| ReadPropExpr.prototype.set = function (value) { |
| return new WritePropExpr(this.receiver, this.name, value, null, this.sourceSpan); |
| }; |
| return ReadPropExpr; |
| }(Expression)); |
| var ReadKeyExpr = /** @class */ (function (_super) { |
| __extends(ReadKeyExpr, _super); |
| function ReadKeyExpr(receiver, index, type, sourceSpan) { |
| var _this = _super.call(this, type, sourceSpan) || this; |
| _this.receiver = receiver; |
| _this.index = index; |
| return _this; |
| } |
| ReadKeyExpr.prototype.isEquivalent = function (e) { |
| return e instanceof ReadKeyExpr && this.receiver.isEquivalent(e.receiver) && |
| this.index.isEquivalent(e.index); |
| }; |
| ReadKeyExpr.prototype.isConstant = function () { return false; }; |
| ReadKeyExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitReadKeyExpr(this, context); |
| }; |
| ReadKeyExpr.prototype.set = function (value) { |
| return new WriteKeyExpr(this.receiver, this.index, value, null, this.sourceSpan); |
| }; |
| return ReadKeyExpr; |
| }(Expression)); |
| var LiteralArrayExpr = /** @class */ (function (_super) { |
| __extends(LiteralArrayExpr, _super); |
| function LiteralArrayExpr(entries, type, sourceSpan) { |
| var _this = _super.call(this, type, sourceSpan) || this; |
| _this.entries = entries; |
| return _this; |
| } |
| LiteralArrayExpr.prototype.isConstant = function () { return this.entries.every(function (e) { return e.isConstant(); }); }; |
| LiteralArrayExpr.prototype.isEquivalent = function (e) { |
| return e instanceof LiteralArrayExpr && areAllEquivalent(this.entries, e.entries); |
| }; |
| LiteralArrayExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitLiteralArrayExpr(this, context); |
| }; |
| return LiteralArrayExpr; |
| }(Expression)); |
| var LiteralMapEntry = /** @class */ (function () { |
| function LiteralMapEntry(key, value, quoted) { |
| this.key = key; |
| this.value = value; |
| this.quoted = quoted; |
| } |
| LiteralMapEntry.prototype.isEquivalent = function (e) { |
| return this.key === e.key && this.value.isEquivalent(e.value); |
| }; |
| return LiteralMapEntry; |
| }()); |
| var LiteralMapExpr = /** @class */ (function (_super) { |
| __extends(LiteralMapExpr, _super); |
| function LiteralMapExpr(entries, type, sourceSpan) { |
| var _this = _super.call(this, type, sourceSpan) || this; |
| _this.entries = entries; |
| _this.valueType = null; |
| if (type) { |
| _this.valueType = type.valueType; |
| } |
| return _this; |
| } |
| LiteralMapExpr.prototype.isEquivalent = function (e) { |
| return e instanceof LiteralMapExpr && areAllEquivalent(this.entries, e.entries); |
| }; |
| LiteralMapExpr.prototype.isConstant = function () { return this.entries.every(function (e) { return e.value.isConstant(); }); }; |
| LiteralMapExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitLiteralMapExpr(this, context); |
| }; |
| return LiteralMapExpr; |
| }(Expression)); |
| var CommaExpr = /** @class */ (function (_super) { |
| __extends(CommaExpr, _super); |
| function CommaExpr(parts, sourceSpan) { |
| var _this = _super.call(this, parts[parts.length - 1].type, sourceSpan) || this; |
| _this.parts = parts; |
| return _this; |
| } |
| CommaExpr.prototype.isEquivalent = function (e) { |
| return e instanceof CommaExpr && areAllEquivalent(this.parts, e.parts); |
| }; |
| CommaExpr.prototype.isConstant = function () { return false; }; |
| CommaExpr.prototype.visitExpression = function (visitor, context) { |
| return visitor.visitCommaExpr(this, context); |
| }; |
| return CommaExpr; |
| }(Expression)); |
| var THIS_EXPR = new ReadVarExpr(exports.BuiltinVar.This, null, null); |
| var SUPER_EXPR = new ReadVarExpr(exports.BuiltinVar.Super, null, null); |
| var CATCH_ERROR_VAR = new ReadVarExpr(exports.BuiltinVar.CatchError, null, null); |
| var CATCH_STACK_VAR = new ReadVarExpr(exports.BuiltinVar.CatchStack, null, null); |
| var NULL_EXPR = new LiteralExpr(null, null, null); |
| var TYPED_NULL_EXPR = new LiteralExpr(null, INFERRED_TYPE, null); |
| (function (StmtModifier) { |
| StmtModifier[StmtModifier["Final"] = 0] = "Final"; |
| StmtModifier[StmtModifier["Private"] = 1] = "Private"; |
| StmtModifier[StmtModifier["Exported"] = 2] = "Exported"; |
| StmtModifier[StmtModifier["Static"] = 3] = "Static"; |
| })(exports.StmtModifier || (exports.StmtModifier = {})); |
| var Statement = /** @class */ (function () { |
| function Statement(modifiers, sourceSpan) { |
| this.modifiers = modifiers || []; |
| this.sourceSpan = sourceSpan || null; |
| } |
| Statement.prototype.hasModifier = function (modifier) { return this.modifiers.indexOf(modifier) !== -1; }; |
| return Statement; |
| }()); |
| var DeclareVarStmt = /** @class */ (function (_super) { |
| __extends(DeclareVarStmt, _super); |
| function DeclareVarStmt(name, value, type, modifiers, sourceSpan) { |
| if (modifiers === void 0) { modifiers = null; } |
| var _this = _super.call(this, modifiers, sourceSpan) || this; |
| _this.name = name; |
| _this.value = value; |
| _this.type = type || (value && value.type) || null; |
| return _this; |
| } |
| DeclareVarStmt.prototype.isEquivalent = function (stmt) { |
| return stmt instanceof DeclareVarStmt && this.name === stmt.name && |
| (this.value ? !!stmt.value && this.value.isEquivalent(stmt.value) : !stmt.value); |
| }; |
| DeclareVarStmt.prototype.visitStatement = function (visitor, context) { |
| return visitor.visitDeclareVarStmt(this, context); |
| }; |
| return DeclareVarStmt; |
| }(Statement)); |
| var DeclareFunctionStmt = /** @class */ (function (_super) { |
| __extends(DeclareFunctionStmt, _super); |
| function DeclareFunctionStmt(name, params, statements, type, modifiers, sourceSpan) { |
| if (modifiers === void 0) { modifiers = null; } |
| var _this = _super.call(this, modifiers, sourceSpan) || this; |
| _this.name = name; |
| _this.params = params; |
| _this.statements = statements; |
| _this.type = type || null; |
| return _this; |
| } |
| DeclareFunctionStmt.prototype.isEquivalent = function (stmt) { |
| return stmt instanceof DeclareFunctionStmt && areAllEquivalent(this.params, stmt.params) && |
| areAllEquivalent(this.statements, stmt.statements); |
| }; |
| DeclareFunctionStmt.prototype.visitStatement = function (visitor, context) { |
| return visitor.visitDeclareFunctionStmt(this, context); |
| }; |
| return DeclareFunctionStmt; |
| }(Statement)); |
| var ExpressionStatement = /** @class */ (function (_super) { |
| __extends(ExpressionStatement, _super); |
| function ExpressionStatement(expr, sourceSpan) { |
| var _this = _super.call(this, null, sourceSpan) || this; |
| _this.expr = expr; |
| return _this; |
| } |
| ExpressionStatement.prototype.isEquivalent = function (stmt) { |
| return stmt instanceof ExpressionStatement && this.expr.isEquivalent(stmt.expr); |
| }; |
| ExpressionStatement.prototype.visitStatement = function (visitor, context) { |
| return visitor.visitExpressionStmt(this, context); |
| }; |
| return ExpressionStatement; |
| }(Statement)); |
| var ReturnStatement = /** @class */ (function (_super) { |
| __extends(ReturnStatement, _super); |
| function ReturnStatement(value, sourceSpan) { |
| var _this = _super.call(this, null, sourceSpan) || this; |
| _this.value = value; |
| return _this; |
| } |
| ReturnStatement.prototype.isEquivalent = function (stmt) { |
| return stmt instanceof ReturnStatement && this.value.isEquivalent(stmt.value); |
| }; |
| ReturnStatement.prototype.visitStatement = function (visitor, context) { |
| return visitor.visitReturnStmt(this, context); |
| }; |
| return ReturnStatement; |
| }(Statement)); |
| var AbstractClassPart = /** @class */ (function () { |
| function AbstractClassPart(type, modifiers) { |
| this.modifiers = modifiers; |
| if (!modifiers) { |
| this.modifiers = []; |
| } |
| this.type = type || null; |
| } |
| AbstractClassPart.prototype.hasModifier = function (modifier) { return this.modifiers.indexOf(modifier) !== -1; }; |
| return AbstractClassPart; |
| }()); |
| var ClassField = /** @class */ (function (_super) { |
| __extends(ClassField, _super); |
| function ClassField(name, type, modifiers, initializer) { |
| if (modifiers === void 0) { modifiers = null; } |
| var _this = _super.call(this, type, modifiers) || this; |
| _this.name = name; |
| _this.initializer = initializer; |
| return _this; |
| } |
| ClassField.prototype.isEquivalent = function (f) { return this.name === f.name; }; |
| return ClassField; |
| }(AbstractClassPart)); |
| var ClassMethod = /** @class */ (function (_super) { |
| __extends(ClassMethod, _super); |
| function ClassMethod(name, params, body, type, modifiers) { |
| if (modifiers === void 0) { modifiers = null; } |
| var _this = _super.call(this, type, modifiers) || this; |
| _this.name = name; |
| _this.params = params; |
| _this.body = body; |
| return _this; |
| } |
| ClassMethod.prototype.isEquivalent = function (m) { |
| return this.name === m.name && areAllEquivalent(this.body, m.body); |
| }; |
| return ClassMethod; |
| }(AbstractClassPart)); |
| var ClassGetter = /** @class */ (function (_super) { |
| __extends(ClassGetter, _super); |
| function ClassGetter(name, body, type, modifiers) { |
| if (modifiers === void 0) { modifiers = null; } |
| var _this = _super.call(this, type, modifiers) || this; |
| _this.name = name; |
| _this.body = body; |
| return _this; |
| } |
| ClassGetter.prototype.isEquivalent = function (m) { |
| return this.name === m.name && areAllEquivalent(this.body, m.body); |
| }; |
| return ClassGetter; |
| }(AbstractClassPart)); |
| var ClassStmt = /** @class */ (function (_super) { |
| __extends(ClassStmt, _super); |
| function ClassStmt(name, parent, fields, getters, constructorMethod, methods, modifiers, sourceSpan) { |
| if (modifiers === void 0) { modifiers = null; } |
| var _this = _super.call(this, modifiers, sourceSpan) || this; |
| _this.name = name; |
| _this.parent = parent; |
| _this.fields = fields; |
| _this.getters = getters; |
| _this.constructorMethod = constructorMethod; |
| _this.methods = methods; |
| return _this; |
| } |
| ClassStmt.prototype.isEquivalent = function (stmt) { |
| return stmt instanceof ClassStmt && this.name === stmt.name && |
| nullSafeIsEquivalent(this.parent, stmt.parent) && |
| areAllEquivalent(this.fields, stmt.fields) && |
| areAllEquivalent(this.getters, stmt.getters) && |
| this.constructorMethod.isEquivalent(stmt.constructorMethod) && |
| areAllEquivalent(this.methods, stmt.methods); |
| }; |
| ClassStmt.prototype.visitStatement = function (visitor, context) { |
| return visitor.visitDeclareClassStmt(this, context); |
| }; |
| return ClassStmt; |
| }(Statement)); |
| var IfStmt = /** @class */ (function (_super) { |
| __extends(IfStmt, _super); |
| function IfStmt(condition, trueCase, falseCase, sourceSpan) { |
| if (falseCase === void 0) { falseCase = []; } |
| var _this = _super.call(this, null, sourceSpan) || this; |
| _this.condition = condition; |
| _this.trueCase = trueCase; |
| _this.falseCase = falseCase; |
| return _this; |
| } |
| IfStmt.prototype.isEquivalent = function (stmt) { |
| return stmt instanceof IfStmt && this.condition.isEquivalent(stmt.condition) && |
| areAllEquivalent(this.trueCase, stmt.trueCase) && |
| areAllEquivalent(this.falseCase, stmt.falseCase); |
| }; |
| IfStmt.prototype.visitStatement = function (visitor, context) { |
| return visitor.visitIfStmt(this, context); |
| }; |
| return IfStmt; |
| }(Statement)); |
| var CommentStmt = /** @class */ (function (_super) { |
| __extends(CommentStmt, _super); |
| function CommentStmt(comment, multiline, sourceSpan) { |
| if (multiline === void 0) { multiline = false; } |
| var _this = _super.call(this, null, sourceSpan) || this; |
| _this.comment = comment; |
| _this.multiline = multiline; |
| return _this; |
| } |
| CommentStmt.prototype.isEquivalent = function (stmt) { return stmt instanceof CommentStmt; }; |
| CommentStmt.prototype.visitStatement = function (visitor, context) { |
| return visitor.visitCommentStmt(this, context); |
| }; |
| return CommentStmt; |
| }(Statement)); |
| var JSDocCommentStmt = /** @class */ (function (_super) { |
| __extends(JSDocCommentStmt, _super); |
| function JSDocCommentStmt(tags, sourceSpan) { |
| if (tags === void 0) { tags = []; } |
| var _this = _super.call(this, null, sourceSpan) || this; |
| _this.tags = tags; |
| return _this; |
| } |
| JSDocCommentStmt.prototype.isEquivalent = function (stmt) { |
| return stmt instanceof JSDocCommentStmt && this.toString() === stmt.toString(); |
| }; |
| JSDocCommentStmt.prototype.visitStatement = function (visitor, context) { |
| return visitor.visitJSDocCommentStmt(this, context); |
| }; |
| JSDocCommentStmt.prototype.toString = function () { return serializeTags(this.tags); }; |
| return JSDocCommentStmt; |
| }(Statement)); |
| var TryCatchStmt = /** @class */ (function (_super) { |
| __extends(TryCatchStmt, _super); |
| function TryCatchStmt(bodyStmts, catchStmts, sourceSpan) { |
| var _this = _super.call(this, null, sourceSpan) || this; |
| _this.bodyStmts = bodyStmts; |
| _this.catchStmts = catchStmts; |
| return _this; |
| } |
| TryCatchStmt.prototype.isEquivalent = function (stmt) { |
| return stmt instanceof TryCatchStmt && areAllEquivalent(this.bodyStmts, stmt.bodyStmts) && |
| areAllEquivalent(this.catchStmts, stmt.catchStmts); |
| }; |
| TryCatchStmt.prototype.visitStatement = function (visitor, context) { |
| return visitor.visitTryCatchStmt(this, context); |
| }; |
| return TryCatchStmt; |
| }(Statement)); |
| var ThrowStmt = /** @class */ (function (_super) { |
| __extends(ThrowStmt, _super); |
| function ThrowStmt(error, sourceSpan) { |
| var _this = _super.call(this, null, sourceSpan) || this; |
| _this.error = error; |
| return _this; |
| } |
| ThrowStmt.prototype.isEquivalent = function (stmt) { |
| return stmt instanceof TryCatchStmt && this.error.isEquivalent(stmt.error); |
| }; |
| ThrowStmt.prototype.visitStatement = function (visitor, context) { |
| return visitor.visitThrowStmt(this, context); |
| }; |
| return ThrowStmt; |
| }(Statement)); |
| var AstTransformer = /** @class */ (function () { |
| function AstTransformer() { |
| } |
| AstTransformer.prototype.transformExpr = function (expr, context) { return expr; }; |
| AstTransformer.prototype.transformStmt = function (stmt, context) { return stmt; }; |
| AstTransformer.prototype.visitReadVarExpr = function (ast, context) { return this.transformExpr(ast, context); }; |
| AstTransformer.prototype.visitWrappedNodeExpr = function (ast, context) { |
| return this.transformExpr(ast, context); |
| }; |
| AstTransformer.prototype.visitTypeofExpr = function (expr, context) { |
| return this.transformExpr(new TypeofExpr(expr.expr.visitExpression(this, context), expr.type, expr.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitWriteVarExpr = function (expr, context) { |
| return this.transformExpr(new WriteVarExpr(expr.name, expr.value.visitExpression(this, context), expr.type, expr.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitWriteKeyExpr = function (expr, context) { |
| return this.transformExpr(new WriteKeyExpr(expr.receiver.visitExpression(this, context), expr.index.visitExpression(this, context), expr.value.visitExpression(this, context), expr.type, expr.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitWritePropExpr = function (expr, context) { |
| return this.transformExpr(new WritePropExpr(expr.receiver.visitExpression(this, context), expr.name, expr.value.visitExpression(this, context), expr.type, expr.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitInvokeMethodExpr = function (ast, context) { |
| var method = ast.builtin || ast.name; |
| return this.transformExpr(new InvokeMethodExpr(ast.receiver.visitExpression(this, context), method, this.visitAllExpressions(ast.args, context), ast.type, ast.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitInvokeFunctionExpr = function (ast, context) { |
| return this.transformExpr(new InvokeFunctionExpr(ast.fn.visitExpression(this, context), this.visitAllExpressions(ast.args, context), ast.type, ast.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitInstantiateExpr = function (ast, context) { |
| return this.transformExpr(new InstantiateExpr(ast.classExpr.visitExpression(this, context), this.visitAllExpressions(ast.args, context), ast.type, ast.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitLiteralExpr = function (ast, context) { return this.transformExpr(ast, context); }; |
| AstTransformer.prototype.visitExternalExpr = function (ast, context) { |
| return this.transformExpr(ast, context); |
| }; |
| AstTransformer.prototype.visitConditionalExpr = function (ast, context) { |
| return this.transformExpr(new ConditionalExpr(ast.condition.visitExpression(this, context), ast.trueCase.visitExpression(this, context), ast.falseCase.visitExpression(this, context), ast.type, ast.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitNotExpr = function (ast, context) { |
| return this.transformExpr(new NotExpr(ast.condition.visitExpression(this, context), ast.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitAssertNotNullExpr = function (ast, context) { |
| return this.transformExpr(new AssertNotNull(ast.condition.visitExpression(this, context), ast.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitCastExpr = function (ast, context) { |
| return this.transformExpr(new CastExpr(ast.value.visitExpression(this, context), ast.type, ast.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitFunctionExpr = function (ast, context) { |
| return this.transformExpr(new FunctionExpr(ast.params, this.visitAllStatements(ast.statements, context), ast.type, ast.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitBinaryOperatorExpr = function (ast, context) { |
| return this.transformExpr(new BinaryOperatorExpr(ast.operator, ast.lhs.visitExpression(this, context), ast.rhs.visitExpression(this, context), ast.type, ast.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitReadPropExpr = function (ast, context) { |
| return this.transformExpr(new ReadPropExpr(ast.receiver.visitExpression(this, context), ast.name, ast.type, ast.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitReadKeyExpr = function (ast, context) { |
| return this.transformExpr(new ReadKeyExpr(ast.receiver.visitExpression(this, context), ast.index.visitExpression(this, context), ast.type, ast.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitLiteralArrayExpr = function (ast, context) { |
| return this.transformExpr(new LiteralArrayExpr(this.visitAllExpressions(ast.entries, context), ast.type, ast.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitLiteralMapExpr = function (ast, context) { |
| var _this = this; |
| var entries = ast.entries.map(function (entry) { return new LiteralMapEntry(entry.key, entry.value.visitExpression(_this, context), entry.quoted); }); |
| var mapType = new MapType(ast.valueType, null); |
| return this.transformExpr(new LiteralMapExpr(entries, mapType, ast.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitCommaExpr = function (ast, context) { |
| return this.transformExpr(new CommaExpr(this.visitAllExpressions(ast.parts, context), ast.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitAllExpressions = function (exprs, context) { |
| var _this = this; |
| return exprs.map(function (expr) { return expr.visitExpression(_this, context); }); |
| }; |
| AstTransformer.prototype.visitDeclareVarStmt = function (stmt, context) { |
| var value = stmt.value && stmt.value.visitExpression(this, context); |
| return this.transformStmt(new DeclareVarStmt(stmt.name, value, stmt.type, stmt.modifiers, stmt.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitDeclareFunctionStmt = function (stmt, context) { |
| return this.transformStmt(new DeclareFunctionStmt(stmt.name, stmt.params, this.visitAllStatements(stmt.statements, context), stmt.type, stmt.modifiers, stmt.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitExpressionStmt = function (stmt, context) { |
| return this.transformStmt(new ExpressionStatement(stmt.expr.visitExpression(this, context), stmt.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitReturnStmt = function (stmt, context) { |
| return this.transformStmt(new ReturnStatement(stmt.value.visitExpression(this, context), stmt.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitDeclareClassStmt = function (stmt, context) { |
| var _this = this; |
| var parent = stmt.parent.visitExpression(this, context); |
| var getters = stmt.getters.map(function (getter) { return new ClassGetter(getter.name, _this.visitAllStatements(getter.body, context), getter.type, getter.modifiers); }); |
| var ctorMethod = stmt.constructorMethod && |
| new ClassMethod(stmt.constructorMethod.name, stmt.constructorMethod.params, this.visitAllStatements(stmt.constructorMethod.body, context), stmt.constructorMethod.type, stmt.constructorMethod.modifiers); |
| var methods = stmt.methods.map(function (method) { return new ClassMethod(method.name, method.params, _this.visitAllStatements(method.body, context), method.type, method.modifiers); }); |
| return this.transformStmt(new ClassStmt(stmt.name, parent, stmt.fields, getters, ctorMethod, methods, stmt.modifiers, stmt.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitIfStmt = function (stmt, context) { |
| return this.transformStmt(new IfStmt(stmt.condition.visitExpression(this, context), this.visitAllStatements(stmt.trueCase, context), this.visitAllStatements(stmt.falseCase, context), stmt.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitTryCatchStmt = function (stmt, context) { |
| return this.transformStmt(new TryCatchStmt(this.visitAllStatements(stmt.bodyStmts, context), this.visitAllStatements(stmt.catchStmts, context), stmt.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitThrowStmt = function (stmt, context) { |
| return this.transformStmt(new ThrowStmt(stmt.error.visitExpression(this, context), stmt.sourceSpan), context); |
| }; |
| AstTransformer.prototype.visitCommentStmt = function (stmt, context) { |
| return this.transformStmt(stmt, context); |
| }; |
| AstTransformer.prototype.visitJSDocCommentStmt = function (stmt, context) { |
| return this.transformStmt(stmt, context); |
| }; |
| AstTransformer.prototype.visitAllStatements = function (stmts, context) { |
| var _this = this; |
| return stmts.map(function (stmt) { return stmt.visitStatement(_this, context); }); |
| }; |
| return AstTransformer; |
| }()); |
| var RecursiveAstVisitor = /** @class */ (function () { |
| function RecursiveAstVisitor() { |
| } |
| RecursiveAstVisitor.prototype.visitType = function (ast, context) { return ast; }; |
| RecursiveAstVisitor.prototype.visitExpression = function (ast, context) { |
| if (ast.type) { |
| ast.type.visitType(this, context); |
| } |
| return ast; |
| }; |
| RecursiveAstVisitor.prototype.visitBuiltinType = function (type, context) { return this.visitType(type, context); }; |
| RecursiveAstVisitor.prototype.visitExpressionType = function (type, context) { |
| var _this = this; |
| type.value.visitExpression(this, context); |
| if (type.typeParams !== null) { |
| type.typeParams.forEach(function (param) { return _this.visitType(param, context); }); |
| } |
| return this.visitType(type, context); |
| }; |
| RecursiveAstVisitor.prototype.visitArrayType = function (type, context) { return this.visitType(type, context); }; |
| RecursiveAstVisitor.prototype.visitMapType = function (type, context) { return this.visitType(type, context); }; |
| RecursiveAstVisitor.prototype.visitWrappedNodeExpr = function (ast, context) { return ast; }; |
| RecursiveAstVisitor.prototype.visitTypeofExpr = function (ast, context) { return this.visitExpression(ast, context); }; |
| RecursiveAstVisitor.prototype.visitReadVarExpr = function (ast, context) { |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitWriteVarExpr = function (ast, context) { |
| ast.value.visitExpression(this, context); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitWriteKeyExpr = function (ast, context) { |
| ast.receiver.visitExpression(this, context); |
| ast.index.visitExpression(this, context); |
| ast.value.visitExpression(this, context); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitWritePropExpr = function (ast, context) { |
| ast.receiver.visitExpression(this, context); |
| ast.value.visitExpression(this, context); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitInvokeMethodExpr = function (ast, context) { |
| ast.receiver.visitExpression(this, context); |
| this.visitAllExpressions(ast.args, context); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitInvokeFunctionExpr = function (ast, context) { |
| ast.fn.visitExpression(this, context); |
| this.visitAllExpressions(ast.args, context); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitInstantiateExpr = function (ast, context) { |
| ast.classExpr.visitExpression(this, context); |
| this.visitAllExpressions(ast.args, context); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitLiteralExpr = function (ast, context) { |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitExternalExpr = function (ast, context) { |
| var _this = this; |
| if (ast.typeParams) { |
| ast.typeParams.forEach(function (type) { return type.visitType(_this, context); }); |
| } |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitConditionalExpr = function (ast, context) { |
| ast.condition.visitExpression(this, context); |
| ast.trueCase.visitExpression(this, context); |
| ast.falseCase.visitExpression(this, context); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitNotExpr = function (ast, context) { |
| ast.condition.visitExpression(this, context); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitAssertNotNullExpr = function (ast, context) { |
| ast.condition.visitExpression(this, context); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitCastExpr = function (ast, context) { |
| ast.value.visitExpression(this, context); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitFunctionExpr = function (ast, context) { |
| this.visitAllStatements(ast.statements, context); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitBinaryOperatorExpr = function (ast, context) { |
| ast.lhs.visitExpression(this, context); |
| ast.rhs.visitExpression(this, context); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitReadPropExpr = function (ast, context) { |
| ast.receiver.visitExpression(this, context); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitReadKeyExpr = function (ast, context) { |
| ast.receiver.visitExpression(this, context); |
| ast.index.visitExpression(this, context); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitLiteralArrayExpr = function (ast, context) { |
| this.visitAllExpressions(ast.entries, context); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitLiteralMapExpr = function (ast, context) { |
| var _this = this; |
| ast.entries.forEach(function (entry) { return entry.value.visitExpression(_this, context); }); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitCommaExpr = function (ast, context) { |
| this.visitAllExpressions(ast.parts, context); |
| return this.visitExpression(ast, context); |
| }; |
| RecursiveAstVisitor.prototype.visitAllExpressions = function (exprs, context) { |
| var _this = this; |
| exprs.forEach(function (expr) { return expr.visitExpression(_this, context); }); |
| }; |
| RecursiveAstVisitor.prototype.visitDeclareVarStmt = function (stmt, context) { |
| if (stmt.value) { |
| stmt.value.visitExpression(this, context); |
| } |
| if (stmt.type) { |
| stmt.type.visitType(this, context); |
| } |
| return stmt; |
| }; |
| RecursiveAstVisitor.prototype.visitDeclareFunctionStmt = function (stmt, context) { |
| this.visitAllStatements(stmt.statements, context); |
| if (stmt.type) { |
| stmt.type.visitType(this, context); |
| } |
| return stmt; |
| }; |
| RecursiveAstVisitor.prototype.visitExpressionStmt = function (stmt, context) { |
| stmt.expr.visitExpression(this, context); |
| return stmt; |
| }; |
| RecursiveAstVisitor.prototype.visitReturnStmt = function (stmt, context) { |
| stmt.value.visitExpression(this, context); |
| return stmt; |
| }; |
| RecursiveAstVisitor.prototype.visitDeclareClassStmt = function (stmt, context) { |
| var _this = this; |
| stmt.parent.visitExpression(this, context); |
| stmt.getters.forEach(function (getter) { return _this.visitAllStatements(getter.body, context); }); |
| if (stmt.constructorMethod) { |
| this.visitAllStatements(stmt.constructorMethod.body, context); |
| } |
| stmt.methods.forEach(function (method) { return _this.visitAllStatements(method.body, context); }); |
| return stmt; |
| }; |
| RecursiveAstVisitor.prototype.visitIfStmt = function (stmt, context) { |
| stmt.condition.visitExpression(this, context); |
| this.visitAllStatements(stmt.trueCase, context); |
| this.visitAllStatements(stmt.falseCase, context); |
| return stmt; |
| }; |
| RecursiveAstVisitor.prototype.visitTryCatchStmt = function (stmt, context) { |
| this.visitAllStatements(stmt.bodyStmts, context); |
| this.visitAllStatements(stmt.catchStmts, context); |
| return stmt; |
| }; |
| RecursiveAstVisitor.prototype.visitThrowStmt = function (stmt, context) { |
| stmt.error.visitExpression(this, context); |
| return stmt; |
| }; |
| RecursiveAstVisitor.prototype.visitCommentStmt = function (stmt, context) { return stmt; }; |
| RecursiveAstVisitor.prototype.visitJSDocCommentStmt = function (stmt, context) { return stmt; }; |
| RecursiveAstVisitor.prototype.visitAllStatements = function (stmts, context) { |
| var _this = this; |
| stmts.forEach(function (stmt) { return stmt.visitStatement(_this, context); }); |
| }; |
| return RecursiveAstVisitor; |
| }()); |
| function findReadVarNames(stmts) { |
| var visitor = new _ReadVarVisitor(); |
| visitor.visitAllStatements(stmts, null); |
| return visitor.varNames; |
| } |
| var _ReadVarVisitor = /** @class */ (function (_super) { |
| __extends(_ReadVarVisitor, _super); |
| function _ReadVarVisitor() { |
| var _this = _super !== null && _super.apply(this, arguments) || this; |
| _this.varNames = new Set(); |
| return _this; |
| } |
| _ReadVarVisitor.prototype.visitDeclareFunctionStmt = function (stmt, context) { |
| // Don't descend into nested functions |
| return stmt; |
| }; |
| _ReadVarVisitor.prototype.visitDeclareClassStmt = function (stmt, context) { |
| // Don't descend into nested classes |
| return stmt; |
| }; |
| _ReadVarVisitor.prototype.visitReadVarExpr = function (ast, context) { |
| if (ast.name) { |
| this.varNames.add(ast.name); |
| } |
| return null; |
| }; |
| return _ReadVarVisitor; |
| }(RecursiveAstVisitor)); |
| function collectExternalReferences(stmts) { |
| var visitor = new _FindExternalReferencesVisitor(); |
| visitor.visitAllStatements(stmts, null); |
| return visitor.externalReferences; |
| } |
| var _FindExternalReferencesVisitor = /** @class */ (function (_super) { |
| __extends(_FindExternalReferencesVisitor, _super); |
| function _FindExternalReferencesVisitor() { |
| var _this = _super !== null && _super.apply(this, arguments) || this; |
| _this.externalReferences = []; |
| return _this; |
| } |
| _FindExternalReferencesVisitor.prototype.visitExternalExpr = function (e, context) { |
| this.externalReferences.push(e.value); |
| return _super.prototype.visitExternalExpr.call(this, e, context); |
| }; |
| return _FindExternalReferencesVisitor; |
| }(RecursiveAstVisitor)); |
| function applySourceSpanToStatementIfNeeded(stmt, sourceSpan) { |
| if (!sourceSpan) { |
| return stmt; |
| } |
| var transformer = new _ApplySourceSpanTransformer(sourceSpan); |
| return stmt.visitStatement(transformer, null); |
| } |
| function applySourceSpanToExpressionIfNeeded(expr, sourceSpan) { |
| if (!sourceSpan) { |
| return expr; |
| } |
| var transformer = new _ApplySourceSpanTransformer(sourceSpan); |
| return expr.visitExpression(transformer, null); |
| } |
| var _ApplySourceSpanTransformer = /** @class */ (function (_super) { |
| __extends(_ApplySourceSpanTransformer, _super); |
| function _ApplySourceSpanTransformer(sourceSpan) { |
| var _this = _super.call(this) || this; |
| _this.sourceSpan = sourceSpan; |
| return _this; |
| } |
| _ApplySourceSpanTransformer.prototype._clone = function (obj) { |
| var clone = Object.create(obj.constructor.prototype); |
| for (var prop in obj) { |
| clone[prop] = obj[prop]; |
| } |
| return clone; |
| }; |
| _ApplySourceSpanTransformer.prototype.transformExpr = function (expr, context) { |
| if (!expr.sourceSpan) { |
| expr = this._clone(expr); |
| expr.sourceSpan = this.sourceSpan; |
| } |
| return expr; |
| }; |
| _ApplySourceSpanTransformer.prototype.transformStmt = function (stmt, context) { |
| if (!stmt.sourceSpan) { |
| stmt = this._clone(stmt); |
| stmt.sourceSpan = this.sourceSpan; |
| } |
| return stmt; |
| }; |
| return _ApplySourceSpanTransformer; |
| }(AstTransformer)); |
| function variable(name, type, sourceSpan) { |
| return new ReadVarExpr(name, type, sourceSpan); |
| } |
| function importExpr(id, typeParams, sourceSpan) { |
| if (typeParams === void 0) { typeParams = null; } |
| return new ExternalExpr(id, null, typeParams, sourceSpan); |
| } |
| function importType(id, typeParams, typeModifiers) { |
| if (typeParams === void 0) { typeParams = null; } |
| if (typeModifiers === void 0) { typeModifiers = null; } |
| return id != null ? expressionType(importExpr(id, typeParams, null), typeModifiers) : null; |
| } |
| function expressionType(expr, typeModifiers, typeParams) { |
| if (typeModifiers === void 0) { typeModifiers = null; } |
| if (typeParams === void 0) { typeParams = null; } |
| return new ExpressionType(expr, typeModifiers, typeParams); |
| } |
| function typeofExpr(expr) { |
| return new TypeofExpr(expr); |
| } |
| function literalArr(values, type, sourceSpan) { |
| return new LiteralArrayExpr(values, type, sourceSpan); |
| } |
| function literalMap(values, type) { |
| if (type === void 0) { type = null; } |
| return new LiteralMapExpr(values.map(function (e) { return new LiteralMapEntry(e.key, e.value, e.quoted); }), type, null); |
| } |
| function not(expr, sourceSpan) { |
| return new NotExpr(expr, sourceSpan); |
| } |
| function assertNotNull(expr, sourceSpan) { |
| return new AssertNotNull(expr, sourceSpan); |
| } |
| function fn(params, body, type, sourceSpan, name) { |
| return new FunctionExpr(params, body, type, sourceSpan, name); |
| } |
| function ifStmt(condition, thenClause, elseClause) { |
| return new IfStmt(condition, thenClause, elseClause); |
| } |
| function literal(value, type, sourceSpan) { |
| return new LiteralExpr(value, type, sourceSpan); |
| } |
| function isNull(exp) { |
| return exp instanceof LiteralExpr && exp.value === null; |
| } |
| /* |
| * Serializes a `Tag` into a string. |
| * Returns a string like " @foo {bar} baz" (note the leading whitespace before `@foo`). |
| */ |
| function tagToString(tag) { |
| var out = ''; |
| if (tag.tagName) { |
| out += " @" + tag.tagName; |
| } |
| if (tag.text) { |
| if (tag.text.match(/\/\*|\*\//)) { |
| throw new Error('JSDoc text cannot contain "/*" and "*/"'); |
| } |
| out += ' ' + tag.text.replace(/@/g, '\\@'); |
| } |
| return out; |
| } |
| function serializeTags(tags) { |
| var e_1, _a; |
| if (tags.length === 0) |
| return ''; |
| var out = '*\n'; |
| try { |
| for (var tags_1 = __values(tags), tags_1_1 = tags_1.next(); !tags_1_1.done; tags_1_1 = tags_1.next()) { |
| var tag = tags_1_1.value; |
| out += ' *'; |
| // If the tagToString is multi-line, insert " * " prefixes on subsequent lines. |
| out += tagToString(tag).replace(/\n/g, '\n * '); |
| out += '\n'; |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (tags_1_1 && !tags_1_1.done && (_a = tags_1.return)) _a.call(tags_1); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| out += ' '; |
| return out; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var DASH_CASE_REGEXP = /-+([a-z0-9])/g; |
| function dashCaseToCamelCase(input) { |
| return input.replace(DASH_CASE_REGEXP, function () { |
| var m = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| m[_i] = arguments[_i]; |
| } |
| return m[1].toUpperCase(); |
| }); |
| } |
| function splitAtColon(input, defaultValues) { |
| return _splitAt(input, ':', defaultValues); |
| } |
| function splitAtPeriod(input, defaultValues) { |
| return _splitAt(input, '.', defaultValues); |
| } |
| function _splitAt(input, character, defaultValues) { |
| var characterIndex = input.indexOf(character); |
| if (characterIndex == -1) |
| return defaultValues; |
| return [input.slice(0, characterIndex).trim(), input.slice(characterIndex + 1).trim()]; |
| } |
| function visitValue(value, visitor, context) { |
| if (Array.isArray(value)) { |
| return visitor.visitArray(value, context); |
| } |
| if (isStrictStringMap(value)) { |
| return visitor.visitStringMap(value, context); |
| } |
| if (value == null || typeof value == 'string' || typeof value == 'number' || |
| typeof value == 'boolean') { |
| return visitor.visitPrimitive(value, context); |
| } |
| return visitor.visitOther(value, context); |
| } |
| function isDefined(val) { |
| return val !== null && val !== undefined; |
| } |
| function noUndefined(val) { |
| return val === undefined ? null : val; |
| } |
| var ValueTransformer = /** @class */ (function () { |
| function ValueTransformer() { |
| } |
| ValueTransformer.prototype.visitArray = function (arr, context) { |
| var _this = this; |
| return arr.map(function (value) { return visitValue(value, _this, context); }); |
| }; |
| ValueTransformer.prototype.visitStringMap = function (map, context) { |
| var _this = this; |
| var result = {}; |
| Object.keys(map).forEach(function (key) { result[key] = visitValue(map[key], _this, context); }); |
| return result; |
| }; |
| ValueTransformer.prototype.visitPrimitive = function (value, context) { return value; }; |
| ValueTransformer.prototype.visitOther = function (value, context) { return value; }; |
| return ValueTransformer; |
| }()); |
| var SyncAsync = { |
| assertSync: function (value) { |
| if (isPromise(value)) { |
| throw new Error("Illegal state: value cannot be a promise"); |
| } |
| return value; |
| }, |
| then: function (value, cb) { return isPromise(value) ? value.then(cb) : cb(value); }, |
| all: function (syncAsyncValues) { |
| return syncAsyncValues.some(isPromise) ? Promise.all(syncAsyncValues) : syncAsyncValues; |
| } |
| }; |
| function error(msg) { |
| throw new Error("Internal Error: " + msg); |
| } |
| function syntaxError(msg, parseErrors) { |
| var error = Error(msg); |
| error[ERROR_SYNTAX_ERROR] = true; |
| if (parseErrors) |
| error[ERROR_PARSE_ERRORS] = parseErrors; |
| return error; |
| } |
| var ERROR_SYNTAX_ERROR = 'ngSyntaxError'; |
| var ERROR_PARSE_ERRORS = 'ngParseErrors'; |
| function isSyntaxError(error) { |
| return error[ERROR_SYNTAX_ERROR]; |
| } |
| function getParseErrors(error) { |
| return error[ERROR_PARSE_ERRORS] || []; |
| } |
| // Escape characters that have a special meaning in Regular Expressions |
| function escapeRegExp(s) { |
| return s.replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1'); |
| } |
| var STRING_MAP_PROTO = Object.getPrototypeOf({}); |
| function isStrictStringMap(obj) { |
| return typeof obj === 'object' && obj !== null && Object.getPrototypeOf(obj) === STRING_MAP_PROTO; |
| } |
| function utf8Encode(str) { |
| var encoded = ''; |
| for (var index = 0; index < str.length; index++) { |
| var codePoint = str.charCodeAt(index); |
| // decode surrogate |
| // see https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae |
| if (codePoint >= 0xd800 && codePoint <= 0xdbff && str.length > (index + 1)) { |
| var low = str.charCodeAt(index + 1); |
| if (low >= 0xdc00 && low <= 0xdfff) { |
| index++; |
| codePoint = ((codePoint - 0xd800) << 10) + low - 0xdc00 + 0x10000; |
| } |
| } |
| if (codePoint <= 0x7f) { |
| encoded += String.fromCharCode(codePoint); |
| } |
| else if (codePoint <= 0x7ff) { |
| encoded += String.fromCharCode(((codePoint >> 6) & 0x1F) | 0xc0, (codePoint & 0x3f) | 0x80); |
| } |
| else if (codePoint <= 0xffff) { |
| encoded += String.fromCharCode((codePoint >> 12) | 0xe0, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80); |
| } |
| else if (codePoint <= 0x1fffff) { |
| encoded += String.fromCharCode(((codePoint >> 18) & 0x07) | 0xf0, ((codePoint >> 12) & 0x3f) | 0x80, ((codePoint >> 6) & 0x3f) | 0x80, (codePoint & 0x3f) | 0x80); |
| } |
| } |
| return encoded; |
| } |
| function stringify(token) { |
| if (typeof token === 'string') { |
| return token; |
| } |
| if (token instanceof Array) { |
| return '[' + token.map(stringify).join(', ') + ']'; |
| } |
| if (token == null) { |
| return '' + token; |
| } |
| if (token.overriddenName) { |
| return "" + token.overriddenName; |
| } |
| if (token.name) { |
| return "" + token.name; |
| } |
| if (!token.toString) { |
| return 'object'; |
| } |
| // WARNING: do not try to `JSON.stringify(token)` here |
| // see https://github.com/angular/angular/issues/23440 |
| var res = token.toString(); |
| if (res == null) { |
| return '' + res; |
| } |
| var newLineIndex = res.indexOf('\n'); |
| return newLineIndex === -1 ? res : res.substring(0, newLineIndex); |
| } |
| /** |
| * Lazily retrieves the reference value from a forwardRef. |
| */ |
| function resolveForwardRef(type) { |
| if (typeof type === 'function' && type.hasOwnProperty('__forward_ref__')) { |
| return type(); |
| } |
| else { |
| return type; |
| } |
| } |
| /** |
| * Determine if the argument is shaped like a Promise |
| */ |
| function isPromise(obj) { |
| // allow any Promise/A+ compliant thenable. |
| // It's up to the caller to ensure that obj.then conforms to the spec |
| return !!obj && typeof obj.then === 'function'; |
| } |
| var Version = /** @class */ (function () { |
| function Version(full) { |
| this.full = full; |
| var splits = full.split('.'); |
| this.major = splits[0]; |
| this.minor = splits[1]; |
| this.patch = splits.slice(2).join('.'); |
| } |
| return Version; |
| }()); |
| var __window = typeof window !== 'undefined' && window; |
| var __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' && |
| self instanceof WorkerGlobalScope && self; |
| var __global = typeof global !== 'undefined' && global; |
| // Check __global first, because in Node tests both __global and __window may be defined and _global |
| // should be __global in that case. |
| var _global = __global || __window || __self; |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var CONSTANT_PREFIX = '_c'; |
| /** |
| * Context to use when producing a key. |
| * |
| * This ensures we see the constant not the reference variable when producing |
| * a key. |
| */ |
| var KEY_CONTEXT = {}; |
| /** |
| * A node that is a place-holder that allows the node to be replaced when the actual |
| * node is known. |
| * |
| * This allows the constant pool to change an expression from a direct reference to |
| * a constant to a shared constant. It returns a fix-up node that is later allowed to |
| * change the referenced expression. |
| */ |
| var FixupExpression = /** @class */ (function (_super) { |
| __extends(FixupExpression, _super); |
| function FixupExpression(resolved) { |
| var _this = _super.call(this, resolved.type) || this; |
| _this.resolved = resolved; |
| _this.original = resolved; |
| return _this; |
| } |
| FixupExpression.prototype.visitExpression = function (visitor, context) { |
| if (context === KEY_CONTEXT) { |
| // When producing a key we want to traverse the constant not the |
| // variable used to refer to it. |
| return this.original.visitExpression(visitor, context); |
| } |
| else { |
| return this.resolved.visitExpression(visitor, context); |
| } |
| }; |
| FixupExpression.prototype.isEquivalent = function (e) { |
| return e instanceof FixupExpression && this.resolved.isEquivalent(e.resolved); |
| }; |
| FixupExpression.prototype.isConstant = function () { return true; }; |
| FixupExpression.prototype.fixup = function (expression) { |
| this.resolved = expression; |
| this.shared = true; |
| }; |
| return FixupExpression; |
| }(Expression)); |
| /** |
| * A constant pool allows a code emitter to share constant in an output context. |
| * |
| * The constant pool also supports sharing access to ivy definitions references. |
| */ |
| var ConstantPool = /** @class */ (function () { |
| function ConstantPool() { |
| this.statements = []; |
| this.literals = new Map(); |
| this.literalFactories = new Map(); |
| this.injectorDefinitions = new Map(); |
| this.directiveDefinitions = new Map(); |
| this.componentDefinitions = new Map(); |
| this.pipeDefinitions = new Map(); |
| this.nextNameIndex = 0; |
| } |
| ConstantPool.prototype.getConstLiteral = function (literal, forceShared) { |
| if (literal instanceof LiteralExpr || literal instanceof FixupExpression) { |
| // Do no put simple literals into the constant pool or try to produce a constant for a |
| // reference to a constant. |
| return literal; |
| } |
| var key = this.keyOf(literal); |
| var fixup = this.literals.get(key); |
| var newValue = false; |
| if (!fixup) { |
| fixup = new FixupExpression(literal); |
| this.literals.set(key, fixup); |
| newValue = true; |
| } |
| if ((!newValue && !fixup.shared) || (newValue && forceShared)) { |
| // Replace the expression with a variable |
| var name_1 = this.freshName(); |
| this.statements.push(variable(name_1).set(literal).toDeclStmt(INFERRED_TYPE, [exports.StmtModifier.Final])); |
| fixup.fixup(variable(name_1)); |
| } |
| return fixup; |
| }; |
| ConstantPool.prototype.getDefinition = function (type, kind, ctx, forceShared) { |
| if (forceShared === void 0) { forceShared = false; } |
| var definitions = this.definitionsOf(kind); |
| var fixup = definitions.get(type); |
| var newValue = false; |
| if (!fixup) { |
| var property = this.propertyNameOf(kind); |
| fixup = new FixupExpression(ctx.importExpr(type).prop(property)); |
| definitions.set(type, fixup); |
| newValue = true; |
| } |
| if ((!newValue && !fixup.shared) || (newValue && forceShared)) { |
| var name_2 = this.freshName(); |
| this.statements.push(variable(name_2).set(fixup.resolved).toDeclStmt(INFERRED_TYPE, [exports.StmtModifier.Final])); |
| fixup.fixup(variable(name_2)); |
| } |
| return fixup; |
| }; |
| ConstantPool.prototype.getLiteralFactory = function (literal$1) { |
| // Create a pure function that builds an array of a mix of constant and variable expressions |
| if (literal$1 instanceof LiteralArrayExpr) { |
| var argumentsForKey = literal$1.entries.map(function (e) { return e.isConstant() ? e : literal(null); }); |
| var key = this.keyOf(literalArr(argumentsForKey)); |
| return this._getLiteralFactory(key, literal$1.entries, function (entries) { return literalArr(entries); }); |
| } |
| else { |
| var expressionForKey = literalMap(literal$1.entries.map(function (e) { return ({ |
| key: e.key, |
| value: e.value.isConstant() ? e.value : literal(null), |
| quoted: e.quoted |
| }); })); |
| var key = this.keyOf(expressionForKey); |
| return this._getLiteralFactory(key, literal$1.entries.map(function (e) { return e.value; }), function (entries) { return literalMap(entries.map(function (value, index) { return ({ |
| key: literal$1.entries[index].key, |
| value: value, |
| quoted: literal$1.entries[index].quoted |
| }); })); }); |
| } |
| }; |
| ConstantPool.prototype._getLiteralFactory = function (key, values, resultMap) { |
| var _this = this; |
| var literalFactory = this.literalFactories.get(key); |
| var literalFactoryArguments = values.filter((function (e) { return !e.isConstant(); })); |
| if (!literalFactory) { |
| var resultExpressions = values.map(function (e, index) { return e.isConstant() ? _this.getConstLiteral(e, true) : variable("a" + index); }); |
| var parameters = resultExpressions.filter(isVariable).map(function (e) { return new FnParam(e.name, DYNAMIC_TYPE); }); |
| var pureFunctionDeclaration = fn(parameters, [new ReturnStatement(resultMap(resultExpressions))], INFERRED_TYPE); |
| var name_3 = this.freshName(); |
| this.statements.push(variable(name_3).set(pureFunctionDeclaration).toDeclStmt(INFERRED_TYPE, [ |
| exports.StmtModifier.Final |
| ])); |
| literalFactory = variable(name_3); |
| this.literalFactories.set(key, literalFactory); |
| } |
| return { literalFactory: literalFactory, literalFactoryArguments: literalFactoryArguments }; |
| }; |
| /** |
| * Produce a unique name. |
| * |
| * The name might be unique among different prefixes if any of the prefixes end in |
| * a digit so the prefix should be a constant string (not based on user input) and |
| * must not end in a digit. |
| */ |
| ConstantPool.prototype.uniqueName = function (prefix) { return "" + prefix + this.nextNameIndex++; }; |
| ConstantPool.prototype.definitionsOf = function (kind) { |
| switch (kind) { |
| case 2 /* Component */: |
| return this.componentDefinitions; |
| case 1 /* Directive */: |
| return this.directiveDefinitions; |
| case 0 /* Injector */: |
| return this.injectorDefinitions; |
| case 3 /* Pipe */: |
| return this.pipeDefinitions; |
| } |
| error("Unknown definition kind " + kind); |
| return this.componentDefinitions; |
| }; |
| ConstantPool.prototype.propertyNameOf = function (kind) { |
| switch (kind) { |
| case 2 /* Component */: |
| return 'ngComponentDef'; |
| case 1 /* Directive */: |
| return 'ngDirectiveDef'; |
| case 0 /* Injector */: |
| return 'ngInjectorDef'; |
| case 3 /* Pipe */: |
| return 'ngPipeDef'; |
| } |
| error("Unknown definition kind " + kind); |
| return '<unknown>'; |
| }; |
| ConstantPool.prototype.freshName = function () { return this.uniqueName(CONSTANT_PREFIX); }; |
| ConstantPool.prototype.keyOf = function (expression) { |
| return expression.visitExpression(new KeyVisitor(), KEY_CONTEXT); |
| }; |
| return ConstantPool; |
| }()); |
| /** |
| * Visitor used to determine if 2 expressions are equivalent and can be shared in the |
| * `ConstantPool`. |
| * |
| * When the id (string) generated by the visitor is equal, expressions are considered equivalent. |
| */ |
| var KeyVisitor = /** @class */ (function () { |
| function KeyVisitor() { |
| this.visitWrappedNodeExpr = invalid; |
| this.visitWriteVarExpr = invalid; |
| this.visitWriteKeyExpr = invalid; |
| this.visitWritePropExpr = invalid; |
| this.visitInvokeMethodExpr = invalid; |
| this.visitInvokeFunctionExpr = invalid; |
| this.visitInstantiateExpr = invalid; |
| this.visitConditionalExpr = invalid; |
| this.visitNotExpr = invalid; |
| this.visitAssertNotNullExpr = invalid; |
| this.visitCastExpr = invalid; |
| this.visitFunctionExpr = invalid; |
| this.visitBinaryOperatorExpr = invalid; |
| this.visitReadPropExpr = invalid; |
| this.visitReadKeyExpr = invalid; |
| this.visitCommaExpr = invalid; |
| } |
| KeyVisitor.prototype.visitLiteralExpr = function (ast) { |
| return "" + (typeof ast.value === 'string' ? '"' + ast.value + '"' : ast.value); |
| }; |
| KeyVisitor.prototype.visitLiteralArrayExpr = function (ast, context) { |
| var _this = this; |
| return "[" + ast.entries.map(function (entry) { return entry.visitExpression(_this, context); }).join(',') + "]"; |
| }; |
| KeyVisitor.prototype.visitLiteralMapExpr = function (ast, context) { |
| var _this = this; |
| var mapKey = function (entry) { |
| var quote = entry.quoted ? '"' : ''; |
| return "" + quote + entry.key + quote; |
| }; |
| var mapEntry = function (entry) { |
| return mapKey(entry) + ":" + entry.value.visitExpression(_this, context); |
| }; |
| return "{" + ast.entries.map(mapEntry).join(','); |
| }; |
| KeyVisitor.prototype.visitExternalExpr = function (ast) { |
| return ast.value.moduleName ? "EX:" + ast.value.moduleName + ":" + ast.value.name : |
| "EX:" + ast.value.runtime.name; |
| }; |
| KeyVisitor.prototype.visitReadVarExpr = function (node) { return "VAR:" + node.name; }; |
| KeyVisitor.prototype.visitTypeofExpr = function (node, context) { |
| return "TYPEOF:" + node.expr.visitExpression(this, context); |
| }; |
| return KeyVisitor; |
| }()); |
| function invalid(arg) { |
| throw new Error("Invalid state: Visitor " + this.constructor.name + " doesn't handle " + arg.constructor.name); |
| } |
| function isVariable(e) { |
| return e instanceof ReadVarExpr; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var CORE = '@angular/core'; |
| var Identifiers = /** @class */ (function () { |
| function Identifiers() { |
| } |
| Identifiers.ANALYZE_FOR_ENTRY_COMPONENTS = { |
| name: 'ANALYZE_FOR_ENTRY_COMPONENTS', |
| moduleName: CORE, |
| }; |
| Identifiers.ElementRef = { name: 'ElementRef', moduleName: CORE }; |
| Identifiers.NgModuleRef = { name: 'NgModuleRef', moduleName: CORE }; |
| Identifiers.ViewContainerRef = { name: 'ViewContainerRef', moduleName: CORE }; |
| Identifiers.ChangeDetectorRef = { |
| name: 'ChangeDetectorRef', |
| moduleName: CORE, |
| }; |
| Identifiers.QueryList = { name: 'QueryList', moduleName: CORE }; |
| Identifiers.TemplateRef = { name: 'TemplateRef', moduleName: CORE }; |
| Identifiers.Renderer2 = { name: 'Renderer2', moduleName: CORE }; |
| Identifiers.CodegenComponentFactoryResolver = { |
| name: 'ɵCodegenComponentFactoryResolver', |
| moduleName: CORE, |
| }; |
| Identifiers.ComponentFactoryResolver = { |
| name: 'ComponentFactoryResolver', |
| moduleName: CORE, |
| }; |
| Identifiers.ComponentFactory = { name: 'ComponentFactory', moduleName: CORE }; |
| Identifiers.ComponentRef = { name: 'ComponentRef', moduleName: CORE }; |
| Identifiers.NgModuleFactory = { name: 'NgModuleFactory', moduleName: CORE }; |
| Identifiers.createModuleFactory = { |
| name: 'ɵcmf', |
| moduleName: CORE, |
| }; |
| Identifiers.moduleDef = { |
| name: 'ɵmod', |
| moduleName: CORE, |
| }; |
| Identifiers.moduleProviderDef = { |
| name: 'ɵmpd', |
| moduleName: CORE, |
| }; |
| Identifiers.RegisterModuleFactoryFn = { |
| name: 'ɵregisterModuleFactory', |
| moduleName: CORE, |
| }; |
| Identifiers.inject = { name: 'ɵɵinject', moduleName: CORE }; |
| Identifiers.INJECTOR = { name: 'INJECTOR', moduleName: CORE }; |
| Identifiers.Injector = { name: 'Injector', moduleName: CORE }; |
| Identifiers.ɵɵdefineInjectable = { name: 'ɵɵdefineInjectable', moduleName: CORE }; |
| Identifiers.InjectableDef = { name: 'ɵɵInjectableDef', moduleName: CORE }; |
| Identifiers.ViewEncapsulation = { |
| name: 'ViewEncapsulation', |
| moduleName: CORE, |
| }; |
| Identifiers.ChangeDetectionStrategy = { |
| name: 'ChangeDetectionStrategy', |
| moduleName: CORE, |
| }; |
| Identifiers.SecurityContext = { |
| name: 'SecurityContext', |
| moduleName: CORE, |
| }; |
| Identifiers.LOCALE_ID = { name: 'LOCALE_ID', moduleName: CORE }; |
| Identifiers.TRANSLATIONS_FORMAT = { |
| name: 'TRANSLATIONS_FORMAT', |
| moduleName: CORE, |
| }; |
| Identifiers.inlineInterpolate = { |
| name: 'ɵinlineInterpolate', |
| moduleName: CORE, |
| }; |
| Identifiers.interpolate = { name: 'ɵinterpolate', moduleName: CORE }; |
| Identifiers.EMPTY_ARRAY = { name: 'ɵEMPTY_ARRAY', moduleName: CORE }; |
| Identifiers.EMPTY_MAP = { name: 'ɵEMPTY_MAP', moduleName: CORE }; |
| Identifiers.Renderer = { name: 'Renderer', moduleName: CORE }; |
| Identifiers.viewDef = { name: 'ɵvid', moduleName: CORE }; |
| Identifiers.elementDef = { name: 'ɵeld', moduleName: CORE }; |
| Identifiers.anchorDef = { name: 'ɵand', moduleName: CORE }; |
| Identifiers.textDef = { name: 'ɵted', moduleName: CORE }; |
| Identifiers.directiveDef = { name: 'ɵdid', moduleName: CORE }; |
| Identifiers.providerDef = { name: 'ɵprd', moduleName: CORE }; |
| Identifiers.queryDef = { name: 'ɵqud', moduleName: CORE }; |
| Identifiers.pureArrayDef = { name: 'ɵpad', moduleName: CORE }; |
| Identifiers.pureObjectDef = { name: 'ɵpod', moduleName: CORE }; |
| Identifiers.purePipeDef = { name: 'ɵppd', moduleName: CORE }; |
| Identifiers.pipeDef = { name: 'ɵpid', moduleName: CORE }; |
| Identifiers.nodeValue = { name: 'ɵnov', moduleName: CORE }; |
| Identifiers.ngContentDef = { name: 'ɵncd', moduleName: CORE }; |
| Identifiers.unwrapValue = { name: 'ɵunv', moduleName: CORE }; |
| Identifiers.createRendererType2 = { name: 'ɵcrt', moduleName: CORE }; |
| // type only |
| Identifiers.RendererType2 = { |
| name: 'RendererType2', |
| moduleName: CORE, |
| }; |
| // type only |
| Identifiers.ViewDefinition = { |
| name: 'ɵViewDefinition', |
| moduleName: CORE, |
| }; |
| Identifiers.createComponentFactory = { name: 'ɵccf', moduleName: CORE }; |
| Identifiers.setClassMetadata = { name: 'ɵsetClassMetadata', moduleName: CORE }; |
| return Identifiers; |
| }()); |
| function createTokenForReference(reference) { |
| return { identifier: { reference: reference } }; |
| } |
| function createTokenForExternalReference(reflector, reference) { |
| return createTokenForReference(reflector.resolveExternalReference(reference)); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * A token representing the a reference to a static type. |
| * |
| * This token is unique for a filePath and name and can be used as a hash table key. |
| */ |
| var StaticSymbol = /** @class */ (function () { |
| function StaticSymbol(filePath, name, members) { |
| this.filePath = filePath; |
| this.name = name; |
| this.members = members; |
| } |
| StaticSymbol.prototype.assertNoMembers = function () { |
| if (this.members.length) { |
| throw new Error("Illegal state: symbol without members expected, but got " + JSON.stringify(this) + "."); |
| } |
| }; |
| return StaticSymbol; |
| }()); |
| /** |
| * A cache of static symbol used by the StaticReflector to return the same symbol for the |
| * same symbol values. |
| */ |
| var StaticSymbolCache = /** @class */ (function () { |
| function StaticSymbolCache() { |
| this.cache = new Map(); |
| } |
| StaticSymbolCache.prototype.get = function (declarationFile, name, members) { |
| members = members || []; |
| var memberSuffix = members.length ? "." + members.join('.') : ''; |
| var key = "\"" + declarationFile + "\"." + name + memberSuffix; |
| var result = this.cache.get(key); |
| if (!result) { |
| result = new StaticSymbol(declarationFile, name, members); |
| this.cache.set(key, result); |
| } |
| return result; |
| }; |
| return StaticSymbolCache; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| // group 0: "[prop] or (event) or @trigger" |
| // group 1: "prop" from "[prop]" |
| // group 2: "event" from "(event)" |
| // group 3: "@trigger" from "@trigger" |
| var HOST_REG_EXP = /^(?:(?:\[([^\]]+)\])|(?:\(([^\)]+)\)))|(\@[-\w]+)$/; |
| function sanitizeIdentifier(name) { |
| return name.replace(/\W/g, '_'); |
| } |
| var _anonymousTypeIndex = 0; |
| function identifierName(compileIdentifier) { |
| if (!compileIdentifier || !compileIdentifier.reference) { |
| return null; |
| } |
| var ref = compileIdentifier.reference; |
| if (ref instanceof StaticSymbol) { |
| return ref.name; |
| } |
| if (ref['__anonymousType']) { |
| return ref['__anonymousType']; |
| } |
| var identifier = stringify(ref); |
| if (identifier.indexOf('(') >= 0) { |
| // case: anonymous functions! |
| identifier = "anonymous_" + _anonymousTypeIndex++; |
| ref['__anonymousType'] = identifier; |
| } |
| else { |
| identifier = sanitizeIdentifier(identifier); |
| } |
| return identifier; |
| } |
| function identifierModuleUrl(compileIdentifier) { |
| var ref = compileIdentifier.reference; |
| if (ref instanceof StaticSymbol) { |
| return ref.filePath; |
| } |
| // Runtime type |
| return "./" + stringify(ref); |
| } |
| function viewClassName(compType, embeddedTemplateIndex) { |
| return "View_" + identifierName({ reference: compType }) + "_" + embeddedTemplateIndex; |
| } |
| function rendererTypeName(compType) { |
| return "RenderType_" + identifierName({ reference: compType }); |
| } |
| function hostViewClassName(compType) { |
| return "HostView_" + identifierName({ reference: compType }); |
| } |
| function componentFactoryName(compType) { |
| return identifierName({ reference: compType }) + "NgFactory"; |
| } |
| (function (CompileSummaryKind) { |
| CompileSummaryKind[CompileSummaryKind["Pipe"] = 0] = "Pipe"; |
| CompileSummaryKind[CompileSummaryKind["Directive"] = 1] = "Directive"; |
| CompileSummaryKind[CompileSummaryKind["NgModule"] = 2] = "NgModule"; |
| CompileSummaryKind[CompileSummaryKind["Injectable"] = 3] = "Injectable"; |
| })(exports.CompileSummaryKind || (exports.CompileSummaryKind = {})); |
| function tokenName(token) { |
| return token.value != null ? sanitizeIdentifier(token.value) : identifierName(token.identifier); |
| } |
| function tokenReference(token) { |
| if (token.identifier != null) { |
| return token.identifier.reference; |
| } |
| else { |
| return token.value; |
| } |
| } |
| /** |
| * Metadata about a stylesheet |
| */ |
| var CompileStylesheetMetadata = /** @class */ (function () { |
| function CompileStylesheetMetadata(_a) { |
| var _b = _a === void 0 ? {} : _a, moduleUrl = _b.moduleUrl, styles = _b.styles, styleUrls = _b.styleUrls; |
| this.moduleUrl = moduleUrl || null; |
| this.styles = _normalizeArray(styles); |
| this.styleUrls = _normalizeArray(styleUrls); |
| } |
| return CompileStylesheetMetadata; |
| }()); |
| /** |
| * Metadata regarding compilation of a template. |
| */ |
| var CompileTemplateMetadata = /** @class */ (function () { |
| function CompileTemplateMetadata(_a) { |
| var encapsulation = _a.encapsulation, template = _a.template, templateUrl = _a.templateUrl, htmlAst = _a.htmlAst, styles = _a.styles, styleUrls = _a.styleUrls, externalStylesheets = _a.externalStylesheets, animations = _a.animations, ngContentSelectors = _a.ngContentSelectors, interpolation = _a.interpolation, isInline = _a.isInline, preserveWhitespaces = _a.preserveWhitespaces; |
| this.encapsulation = encapsulation; |
| this.template = template; |
| this.templateUrl = templateUrl; |
| this.htmlAst = htmlAst; |
| this.styles = _normalizeArray(styles); |
| this.styleUrls = _normalizeArray(styleUrls); |
| this.externalStylesheets = _normalizeArray(externalStylesheets); |
| this.animations = animations ? flatten(animations) : []; |
| this.ngContentSelectors = ngContentSelectors || []; |
| if (interpolation && interpolation.length != 2) { |
| throw new Error("'interpolation' should have a start and an end symbol."); |
| } |
| this.interpolation = interpolation; |
| this.isInline = isInline; |
| this.preserveWhitespaces = preserveWhitespaces; |
| } |
| CompileTemplateMetadata.prototype.toSummary = function () { |
| return { |
| ngContentSelectors: this.ngContentSelectors, |
| encapsulation: this.encapsulation, |
| styles: this.styles, |
| animations: this.animations |
| }; |
| }; |
| return CompileTemplateMetadata; |
| }()); |
| /** |
| * Metadata regarding compilation of a directive. |
| */ |
| var CompileDirectiveMetadata = /** @class */ (function () { |
| function CompileDirectiveMetadata(_a) { |
| var isHost = _a.isHost, type = _a.type, isComponent = _a.isComponent, selector = _a.selector, exportAs = _a.exportAs, changeDetection = _a.changeDetection, inputs = _a.inputs, outputs = _a.outputs, hostListeners = _a.hostListeners, hostProperties = _a.hostProperties, hostAttributes = _a.hostAttributes, providers = _a.providers, viewProviders = _a.viewProviders, queries = _a.queries, guards = _a.guards, viewQueries = _a.viewQueries, entryComponents = _a.entryComponents, template = _a.template, componentViewType = _a.componentViewType, rendererType = _a.rendererType, componentFactory = _a.componentFactory; |
| this.isHost = !!isHost; |
| this.type = type; |
| this.isComponent = isComponent; |
| this.selector = selector; |
| this.exportAs = exportAs; |
| this.changeDetection = changeDetection; |
| this.inputs = inputs; |
| this.outputs = outputs; |
| this.hostListeners = hostListeners; |
| this.hostProperties = hostProperties; |
| this.hostAttributes = hostAttributes; |
| this.providers = _normalizeArray(providers); |
| this.viewProviders = _normalizeArray(viewProviders); |
| this.queries = _normalizeArray(queries); |
| this.guards = guards; |
| this.viewQueries = _normalizeArray(viewQueries); |
| this.entryComponents = _normalizeArray(entryComponents); |
| this.template = template; |
| this.componentViewType = componentViewType; |
| this.rendererType = rendererType; |
| this.componentFactory = componentFactory; |
| } |
| CompileDirectiveMetadata.create = function (_a) { |
| var isHost = _a.isHost, type = _a.type, isComponent = _a.isComponent, selector = _a.selector, exportAs = _a.exportAs, changeDetection = _a.changeDetection, inputs = _a.inputs, outputs = _a.outputs, host = _a.host, providers = _a.providers, viewProviders = _a.viewProviders, queries = _a.queries, guards = _a.guards, viewQueries = _a.viewQueries, entryComponents = _a.entryComponents, template = _a.template, componentViewType = _a.componentViewType, rendererType = _a.rendererType, componentFactory = _a.componentFactory; |
| var hostListeners = {}; |
| var hostProperties = {}; |
| var hostAttributes = {}; |
| if (host != null) { |
| Object.keys(host).forEach(function (key) { |
| var value = host[key]; |
| var matches = key.match(HOST_REG_EXP); |
| if (matches === null) { |
| hostAttributes[key] = value; |
| } |
| else if (matches[1] != null) { |
| hostProperties[matches[1]] = value; |
| } |
| else if (matches[2] != null) { |
| hostListeners[matches[2]] = value; |
| } |
| }); |
| } |
| var inputsMap = {}; |
| if (inputs != null) { |
| inputs.forEach(function (bindConfig) { |
| // canonical syntax: `dirProp: elProp` |
| // if there is no `:`, use dirProp = elProp |
| var parts = splitAtColon(bindConfig, [bindConfig, bindConfig]); |
| inputsMap[parts[0]] = parts[1]; |
| }); |
| } |
| var outputsMap = {}; |
| if (outputs != null) { |
| outputs.forEach(function (bindConfig) { |
| // canonical syntax: `dirProp: elProp` |
| // if there is no `:`, use dirProp = elProp |
| var parts = splitAtColon(bindConfig, [bindConfig, bindConfig]); |
| outputsMap[parts[0]] = parts[1]; |
| }); |
| } |
| return new CompileDirectiveMetadata({ |
| isHost: isHost, |
| type: type, |
| isComponent: !!isComponent, selector: selector, exportAs: exportAs, changeDetection: changeDetection, |
| inputs: inputsMap, |
| outputs: outputsMap, |
| hostListeners: hostListeners, |
| hostProperties: hostProperties, |
| hostAttributes: hostAttributes, |
| providers: providers, |
| viewProviders: viewProviders, |
| queries: queries, |
| guards: guards, |
| viewQueries: viewQueries, |
| entryComponents: entryComponents, |
| template: template, |
| componentViewType: componentViewType, |
| rendererType: rendererType, |
| componentFactory: componentFactory, |
| }); |
| }; |
| CompileDirectiveMetadata.prototype.toSummary = function () { |
| return { |
| summaryKind: exports.CompileSummaryKind.Directive, |
| type: this.type, |
| isComponent: this.isComponent, |
| selector: this.selector, |
| exportAs: this.exportAs, |
| inputs: this.inputs, |
| outputs: this.outputs, |
| hostListeners: this.hostListeners, |
| hostProperties: this.hostProperties, |
| hostAttributes: this.hostAttributes, |
| providers: this.providers, |
| viewProviders: this.viewProviders, |
| queries: this.queries, |
| guards: this.guards, |
| viewQueries: this.viewQueries, |
| entryComponents: this.entryComponents, |
| changeDetection: this.changeDetection, |
| template: this.template && this.template.toSummary(), |
| componentViewType: this.componentViewType, |
| rendererType: this.rendererType, |
| componentFactory: this.componentFactory |
| }; |
| }; |
| return CompileDirectiveMetadata; |
| }()); |
| var CompilePipeMetadata = /** @class */ (function () { |
| function CompilePipeMetadata(_a) { |
| var type = _a.type, name = _a.name, pure = _a.pure; |
| this.type = type; |
| this.name = name; |
| this.pure = !!pure; |
| } |
| CompilePipeMetadata.prototype.toSummary = function () { |
| return { |
| summaryKind: exports.CompileSummaryKind.Pipe, |
| type: this.type, |
| name: this.name, |
| pure: this.pure |
| }; |
| }; |
| return CompilePipeMetadata; |
| }()); |
| var CompileShallowModuleMetadata = /** @class */ (function () { |
| function CompileShallowModuleMetadata() { |
| } |
| return CompileShallowModuleMetadata; |
| }()); |
| /** |
| * Metadata regarding compilation of a module. |
| */ |
| var CompileNgModuleMetadata = /** @class */ (function () { |
| function CompileNgModuleMetadata(_a) { |
| var type = _a.type, providers = _a.providers, declaredDirectives = _a.declaredDirectives, exportedDirectives = _a.exportedDirectives, declaredPipes = _a.declaredPipes, exportedPipes = _a.exportedPipes, entryComponents = _a.entryComponents, bootstrapComponents = _a.bootstrapComponents, importedModules = _a.importedModules, exportedModules = _a.exportedModules, schemas = _a.schemas, transitiveModule = _a.transitiveModule, id = _a.id; |
| this.type = type || null; |
| this.declaredDirectives = _normalizeArray(declaredDirectives); |
| this.exportedDirectives = _normalizeArray(exportedDirectives); |
| this.declaredPipes = _normalizeArray(declaredPipes); |
| this.exportedPipes = _normalizeArray(exportedPipes); |
| this.providers = _normalizeArray(providers); |
| this.entryComponents = _normalizeArray(entryComponents); |
| this.bootstrapComponents = _normalizeArray(bootstrapComponents); |
| this.importedModules = _normalizeArray(importedModules); |
| this.exportedModules = _normalizeArray(exportedModules); |
| this.schemas = _normalizeArray(schemas); |
| this.id = id || null; |
| this.transitiveModule = transitiveModule || null; |
| } |
| CompileNgModuleMetadata.prototype.toSummary = function () { |
| var module = this.transitiveModule; |
| return { |
| summaryKind: exports.CompileSummaryKind.NgModule, |
| type: this.type, |
| entryComponents: module.entryComponents, |
| providers: module.providers, |
| modules: module.modules, |
| exportedDirectives: module.exportedDirectives, |
| exportedPipes: module.exportedPipes |
| }; |
| }; |
| return CompileNgModuleMetadata; |
| }()); |
| var TransitiveCompileNgModuleMetadata = /** @class */ (function () { |
| function TransitiveCompileNgModuleMetadata() { |
| this.directivesSet = new Set(); |
| this.directives = []; |
| this.exportedDirectivesSet = new Set(); |
| this.exportedDirectives = []; |
| this.pipesSet = new Set(); |
| this.pipes = []; |
| this.exportedPipesSet = new Set(); |
| this.exportedPipes = []; |
| this.modulesSet = new Set(); |
| this.modules = []; |
| this.entryComponentsSet = new Set(); |
| this.entryComponents = []; |
| this.providers = []; |
| } |
| TransitiveCompileNgModuleMetadata.prototype.addProvider = function (provider, module) { |
| this.providers.push({ provider: provider, module: module }); |
| }; |
| TransitiveCompileNgModuleMetadata.prototype.addDirective = function (id) { |
| if (!this.directivesSet.has(id.reference)) { |
| this.directivesSet.add(id.reference); |
| this.directives.push(id); |
| } |
| }; |
| TransitiveCompileNgModuleMetadata.prototype.addExportedDirective = function (id) { |
| if (!this.exportedDirectivesSet.has(id.reference)) { |
| this.exportedDirectivesSet.add(id.reference); |
| this.exportedDirectives.push(id); |
| } |
| }; |
| TransitiveCompileNgModuleMetadata.prototype.addPipe = function (id) { |
| if (!this.pipesSet.has(id.reference)) { |
| this.pipesSet.add(id.reference); |
| this.pipes.push(id); |
| } |
| }; |
| TransitiveCompileNgModuleMetadata.prototype.addExportedPipe = function (id) { |
| if (!this.exportedPipesSet.has(id.reference)) { |
| this.exportedPipesSet.add(id.reference); |
| this.exportedPipes.push(id); |
| } |
| }; |
| TransitiveCompileNgModuleMetadata.prototype.addModule = function (id) { |
| if (!this.modulesSet.has(id.reference)) { |
| this.modulesSet.add(id.reference); |
| this.modules.push(id); |
| } |
| }; |
| TransitiveCompileNgModuleMetadata.prototype.addEntryComponent = function (ec) { |
| if (!this.entryComponentsSet.has(ec.componentType)) { |
| this.entryComponentsSet.add(ec.componentType); |
| this.entryComponents.push(ec); |
| } |
| }; |
| return TransitiveCompileNgModuleMetadata; |
| }()); |
| function _normalizeArray(obj) { |
| return obj || []; |
| } |
| var ProviderMeta = /** @class */ (function () { |
| function ProviderMeta(token, _a) { |
| var useClass = _a.useClass, useValue = _a.useValue, useExisting = _a.useExisting, useFactory = _a.useFactory, deps = _a.deps, multi = _a.multi; |
| this.token = token; |
| this.useClass = useClass || null; |
| this.useValue = useValue; |
| this.useExisting = useExisting; |
| this.useFactory = useFactory || null; |
| this.dependencies = deps || null; |
| this.multi = !!multi; |
| } |
| return ProviderMeta; |
| }()); |
| function flatten(list) { |
| return list.reduce(function (flat, item) { |
| var flatItem = Array.isArray(item) ? flatten(item) : item; |
| return flat.concat(flatItem); |
| }, []); |
| } |
| function jitSourceUrl(url) { |
| // Note: We need 3 "/" so that ng shows up as a separate domain |
| // in the chrome dev tools. |
| return url.replace(/(\w+:\/\/[\w:-]+)?(\/+)?/, 'ng:///'); |
| } |
| function templateSourceUrl(ngModuleType, compMeta, templateMeta) { |
| var url; |
| if (templateMeta.isInline) { |
| if (compMeta.type.reference instanceof StaticSymbol) { |
| // Note: a .ts file might contain multiple components with inline templates, |
| // so we need to give them unique urls, as these will be used for sourcemaps. |
| url = compMeta.type.reference.filePath + "." + compMeta.type.reference.name + ".html"; |
| } |
| else { |
| url = identifierName(ngModuleType) + "/" + identifierName(compMeta.type) + ".html"; |
| } |
| } |
| else { |
| url = templateMeta.templateUrl; |
| } |
| return compMeta.type.reference instanceof StaticSymbol ? url : jitSourceUrl(url); |
| } |
| function sharedStylesheetJitUrl(meta, id) { |
| var pathParts = meta.moduleUrl.split(/\/\\/g); |
| var baseName = pathParts[pathParts.length - 1]; |
| return jitSourceUrl("css/" + id + baseName + ".ngstyle.js"); |
| } |
| function ngModuleJitUrl(moduleMeta) { |
| return jitSourceUrl(identifierName(moduleMeta.type) + "/module.ngfactory.js"); |
| } |
| function templateJitUrl(ngModuleType, compMeta) { |
| return jitSourceUrl(identifierName(ngModuleType) + "/" + identifierName(compMeta.type) + ".ngfactory.js"); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var CORE$1 = '@angular/core'; |
| var Identifiers$1 = /** @class */ (function () { |
| function Identifiers() { |
| } |
| /* Methods */ |
| Identifiers.NEW_METHOD = 'factory'; |
| Identifiers.TRANSFORM_METHOD = 'transform'; |
| Identifiers.PATCH_DEPS = 'patchedDeps'; |
| /* Instructions */ |
| Identifiers.namespaceHTML = { name: 'ɵɵnamespaceHTML', moduleName: CORE$1 }; |
| Identifiers.namespaceMathML = { name: 'ɵɵnamespaceMathML', moduleName: CORE$1 }; |
| Identifiers.namespaceSVG = { name: 'ɵɵnamespaceSVG', moduleName: CORE$1 }; |
| Identifiers.element = { name: 'ɵɵelement', moduleName: CORE$1 }; |
| Identifiers.elementStart = { name: 'ɵɵelementStart', moduleName: CORE$1 }; |
| Identifiers.elementEnd = { name: 'ɵɵelementEnd', moduleName: CORE$1 }; |
| Identifiers.select = { name: 'ɵɵselect', moduleName: CORE$1 }; |
| Identifiers.updateSyntheticHostBinding = { name: 'ɵɵupdateSyntheticHostBinding', moduleName: CORE$1 }; |
| Identifiers.componentHostSyntheticListener = { name: 'ɵɵcomponentHostSyntheticListener', moduleName: CORE$1 }; |
| Identifiers.attribute = { name: 'ɵɵattribute', moduleName: CORE$1 }; |
| Identifiers.attributeInterpolate1 = { name: 'ɵɵattributeInterpolate1', moduleName: CORE$1 }; |
| Identifiers.attributeInterpolate2 = { name: 'ɵɵattributeInterpolate2', moduleName: CORE$1 }; |
| Identifiers.attributeInterpolate3 = { name: 'ɵɵattributeInterpolate3', moduleName: CORE$1 }; |
| Identifiers.attributeInterpolate4 = { name: 'ɵɵattributeInterpolate4', moduleName: CORE$1 }; |
| Identifiers.attributeInterpolate5 = { name: 'ɵɵattributeInterpolate5', moduleName: CORE$1 }; |
| Identifiers.attributeInterpolate6 = { name: 'ɵɵattributeInterpolate6', moduleName: CORE$1 }; |
| Identifiers.attributeInterpolate7 = { name: 'ɵɵattributeInterpolate7', moduleName: CORE$1 }; |
| Identifiers.attributeInterpolate8 = { name: 'ɵɵattributeInterpolate8', moduleName: CORE$1 }; |
| Identifiers.attributeInterpolateV = { name: 'ɵɵattributeInterpolateV', moduleName: CORE$1 }; |
| Identifiers.classProp = { name: 'ɵɵclassProp', moduleName: CORE$1 }; |
| Identifiers.elementContainerStart = { name: 'ɵɵelementContainerStart', moduleName: CORE$1 }; |
| Identifiers.elementContainerEnd = { name: 'ɵɵelementContainerEnd', moduleName: CORE$1 }; |
| Identifiers.styling = { name: 'ɵɵstyling', moduleName: CORE$1 }; |
| Identifiers.styleMap = { name: 'ɵɵstyleMap', moduleName: CORE$1 }; |
| Identifiers.classMap = { name: 'ɵɵclassMap', moduleName: CORE$1 }; |
| Identifiers.styleProp = { name: 'ɵɵstyleProp', moduleName: CORE$1 }; |
| Identifiers.stylingApply = { name: 'ɵɵstylingApply', moduleName: CORE$1 }; |
| Identifiers.styleSanitizer = { name: 'ɵɵstyleSanitizer', moduleName: CORE$1 }; |
| Identifiers.elementHostAttrs = { name: 'ɵɵelementHostAttrs', moduleName: CORE$1 }; |
| Identifiers.containerCreate = { name: 'ɵɵcontainer', moduleName: CORE$1 }; |
| Identifiers.nextContext = { name: 'ɵɵnextContext', moduleName: CORE$1 }; |
| Identifiers.templateCreate = { name: 'ɵɵtemplate', moduleName: CORE$1 }; |
| Identifiers.text = { name: 'ɵɵtext', moduleName: CORE$1 }; |
| Identifiers.textBinding = { name: 'ɵɵtextBinding', moduleName: CORE$1 }; |
| Identifiers.enableBindings = { name: 'ɵɵenableBindings', moduleName: CORE$1 }; |
| Identifiers.disableBindings = { name: 'ɵɵdisableBindings', moduleName: CORE$1 }; |
| Identifiers.allocHostVars = { name: 'ɵɵallocHostVars', moduleName: CORE$1 }; |
| Identifiers.getCurrentView = { name: 'ɵɵgetCurrentView', moduleName: CORE$1 }; |
| Identifiers.textInterpolate = { name: 'ɵɵtextInterpolate', moduleName: CORE$1 }; |
| Identifiers.textInterpolate1 = { name: 'ɵɵtextInterpolate1', moduleName: CORE$1 }; |
| Identifiers.textInterpolate2 = { name: 'ɵɵtextInterpolate2', moduleName: CORE$1 }; |
| Identifiers.textInterpolate3 = { name: 'ɵɵtextInterpolate3', moduleName: CORE$1 }; |
| Identifiers.textInterpolate4 = { name: 'ɵɵtextInterpolate4', moduleName: CORE$1 }; |
| Identifiers.textInterpolate5 = { name: 'ɵɵtextInterpolate5', moduleName: CORE$1 }; |
| Identifiers.textInterpolate6 = { name: 'ɵɵtextInterpolate6', moduleName: CORE$1 }; |
| Identifiers.textInterpolate7 = { name: 'ɵɵtextInterpolate7', moduleName: CORE$1 }; |
| Identifiers.textInterpolate8 = { name: 'ɵɵtextInterpolate8', moduleName: CORE$1 }; |
| Identifiers.textInterpolateV = { name: 'ɵɵtextInterpolateV', moduleName: CORE$1 }; |
| Identifiers.restoreView = { name: 'ɵɵrestoreView', moduleName: CORE$1 }; |
| Identifiers.interpolation1 = { name: 'ɵɵinterpolation1', moduleName: CORE$1 }; |
| Identifiers.interpolation2 = { name: 'ɵɵinterpolation2', moduleName: CORE$1 }; |
| Identifiers.interpolation3 = { name: 'ɵɵinterpolation3', moduleName: CORE$1 }; |
| Identifiers.interpolation4 = { name: 'ɵɵinterpolation4', moduleName: CORE$1 }; |
| Identifiers.interpolation5 = { name: 'ɵɵinterpolation5', moduleName: CORE$1 }; |
| Identifiers.interpolation6 = { name: 'ɵɵinterpolation6', moduleName: CORE$1 }; |
| Identifiers.interpolation7 = { name: 'ɵɵinterpolation7', moduleName: CORE$1 }; |
| Identifiers.interpolation8 = { name: 'ɵɵinterpolation8', moduleName: CORE$1 }; |
| Identifiers.interpolationV = { name: 'ɵɵinterpolationV', moduleName: CORE$1 }; |
| Identifiers.pureFunction0 = { name: 'ɵɵpureFunction0', moduleName: CORE$1 }; |
| Identifiers.pureFunction1 = { name: 'ɵɵpureFunction1', moduleName: CORE$1 }; |
| Identifiers.pureFunction2 = { name: 'ɵɵpureFunction2', moduleName: CORE$1 }; |
| Identifiers.pureFunction3 = { name: 'ɵɵpureFunction3', moduleName: CORE$1 }; |
| Identifiers.pureFunction4 = { name: 'ɵɵpureFunction4', moduleName: CORE$1 }; |
| Identifiers.pureFunction5 = { name: 'ɵɵpureFunction5', moduleName: CORE$1 }; |
| Identifiers.pureFunction6 = { name: 'ɵɵpureFunction6', moduleName: CORE$1 }; |
| Identifiers.pureFunction7 = { name: 'ɵɵpureFunction7', moduleName: CORE$1 }; |
| Identifiers.pureFunction8 = { name: 'ɵɵpureFunction8', moduleName: CORE$1 }; |
| Identifiers.pureFunctionV = { name: 'ɵɵpureFunctionV', moduleName: CORE$1 }; |
| Identifiers.pipeBind1 = { name: 'ɵɵpipeBind1', moduleName: CORE$1 }; |
| Identifiers.pipeBind2 = { name: 'ɵɵpipeBind2', moduleName: CORE$1 }; |
| Identifiers.pipeBind3 = { name: 'ɵɵpipeBind3', moduleName: CORE$1 }; |
| Identifiers.pipeBind4 = { name: 'ɵɵpipeBind4', moduleName: CORE$1 }; |
| Identifiers.pipeBindV = { name: 'ɵɵpipeBindV', moduleName: CORE$1 }; |
| Identifiers.property = { name: 'ɵɵproperty', moduleName: CORE$1 }; |
| Identifiers.propertyInterpolate = { name: 'ɵɵpropertyInterpolate', moduleName: CORE$1 }; |
| Identifiers.propertyInterpolate1 = { name: 'ɵɵpropertyInterpolate1', moduleName: CORE$1 }; |
| Identifiers.propertyInterpolate2 = { name: 'ɵɵpropertyInterpolate2', moduleName: CORE$1 }; |
| Identifiers.propertyInterpolate3 = { name: 'ɵɵpropertyInterpolate3', moduleName: CORE$1 }; |
| Identifiers.propertyInterpolate4 = { name: 'ɵɵpropertyInterpolate4', moduleName: CORE$1 }; |
| Identifiers.propertyInterpolate5 = { name: 'ɵɵpropertyInterpolate5', moduleName: CORE$1 }; |
| Identifiers.propertyInterpolate6 = { name: 'ɵɵpropertyInterpolate6', moduleName: CORE$1 }; |
| Identifiers.propertyInterpolate7 = { name: 'ɵɵpropertyInterpolate7', moduleName: CORE$1 }; |
| Identifiers.propertyInterpolate8 = { name: 'ɵɵpropertyInterpolate8', moduleName: CORE$1 }; |
| Identifiers.propertyInterpolateV = { name: 'ɵɵpropertyInterpolateV', moduleName: CORE$1 }; |
| Identifiers.i18n = { name: 'ɵɵi18n', moduleName: CORE$1 }; |
| Identifiers.i18nAttributes = { name: 'ɵɵi18nAttributes', moduleName: CORE$1 }; |
| Identifiers.i18nExp = { name: 'ɵɵi18nExp', moduleName: CORE$1 }; |
| Identifiers.i18nStart = { name: 'ɵɵi18nStart', moduleName: CORE$1 }; |
| Identifiers.i18nEnd = { name: 'ɵɵi18nEnd', moduleName: CORE$1 }; |
| Identifiers.i18nApply = { name: 'ɵɵi18nApply', moduleName: CORE$1 }; |
| Identifiers.i18nPostprocess = { name: 'ɵɵi18nPostprocess', moduleName: CORE$1 }; |
| Identifiers.i18nLocalize = { name: 'ɵɵi18nLocalize', moduleName: CORE$1 }; |
| Identifiers.load = { name: 'ɵɵload', moduleName: CORE$1 }; |
| Identifiers.pipe = { name: 'ɵɵpipe', moduleName: CORE$1 }; |
| Identifiers.projection = { name: 'ɵɵprojection', moduleName: CORE$1 }; |
| Identifiers.projectionDef = { name: 'ɵɵprojectionDef', moduleName: CORE$1 }; |
| Identifiers.reference = { name: 'ɵɵreference', moduleName: CORE$1 }; |
| Identifiers.inject = { name: 'ɵɵinject', moduleName: CORE$1 }; |
| Identifiers.injectAttribute = { name: 'ɵɵinjectAttribute', moduleName: CORE$1 }; |
| Identifiers.directiveInject = { name: 'ɵɵdirectiveInject', moduleName: CORE$1 }; |
| Identifiers.templateRefExtractor = { name: 'ɵɵtemplateRefExtractor', moduleName: CORE$1 }; |
| Identifiers.resolveWindow = { name: 'ɵɵresolveWindow', moduleName: CORE$1 }; |
| Identifiers.resolveDocument = { name: 'ɵɵresolveDocument', moduleName: CORE$1 }; |
| Identifiers.resolveBody = { name: 'ɵɵresolveBody', moduleName: CORE$1 }; |
| Identifiers.defineBase = { name: 'ɵɵdefineBase', moduleName: CORE$1 }; |
| Identifiers.BaseDef = { |
| name: 'ɵɵBaseDef', |
| moduleName: CORE$1, |
| }; |
| Identifiers.defineComponent = { name: 'ɵɵdefineComponent', moduleName: CORE$1 }; |
| Identifiers.setComponentScope = { name: 'ɵɵsetComponentScope', moduleName: CORE$1 }; |
| Identifiers.ComponentDefWithMeta = { |
| name: 'ɵɵComponentDefWithMeta', |
| moduleName: CORE$1, |
| }; |
| Identifiers.defineDirective = { |
| name: 'ɵɵdefineDirective', |
| moduleName: CORE$1, |
| }; |
| Identifiers.DirectiveDefWithMeta = { |
| name: 'ɵɵDirectiveDefWithMeta', |
| moduleName: CORE$1, |
| }; |
| Identifiers.InjectorDef = { |
| name: 'ɵɵInjectorDef', |
| moduleName: CORE$1, |
| }; |
| Identifiers.defineInjector = { |
| name: 'ɵɵdefineInjector', |
| moduleName: CORE$1, |
| }; |
| Identifiers.NgModuleDefWithMeta = { |
| name: 'ɵɵNgModuleDefWithMeta', |
| moduleName: CORE$1, |
| }; |
| Identifiers.defineNgModule = { name: 'ɵɵdefineNgModule', moduleName: CORE$1 }; |
| Identifiers.setNgModuleScope = { name: 'ɵɵsetNgModuleScope', moduleName: CORE$1 }; |
| Identifiers.PipeDefWithMeta = { name: 'ɵɵPipeDefWithMeta', moduleName: CORE$1 }; |
| Identifiers.definePipe = { name: 'ɵɵdefinePipe', moduleName: CORE$1 }; |
| Identifiers.queryRefresh = { name: 'ɵɵqueryRefresh', moduleName: CORE$1 }; |
| Identifiers.viewQuery = { name: 'ɵɵviewQuery', moduleName: CORE$1 }; |
| Identifiers.staticViewQuery = { name: 'ɵɵstaticViewQuery', moduleName: CORE$1 }; |
| Identifiers.staticContentQuery = { name: 'ɵɵstaticContentQuery', moduleName: CORE$1 }; |
| Identifiers.loadViewQuery = { name: 'ɵɵloadViewQuery', moduleName: CORE$1 }; |
| Identifiers.contentQuery = { name: 'ɵɵcontentQuery', moduleName: CORE$1 }; |
| Identifiers.loadContentQuery = { name: 'ɵɵloadContentQuery', moduleName: CORE$1 }; |
| Identifiers.NgOnChangesFeature = { name: 'ɵɵNgOnChangesFeature', moduleName: CORE$1 }; |
| Identifiers.InheritDefinitionFeature = { name: 'ɵɵInheritDefinitionFeature', moduleName: CORE$1 }; |
| Identifiers.ProvidersFeature = { name: 'ɵɵProvidersFeature', moduleName: CORE$1 }; |
| Identifiers.listener = { name: 'ɵɵlistener', moduleName: CORE$1 }; |
| Identifiers.getFactoryOf = { |
| name: 'ɵɵgetFactoryOf', |
| moduleName: CORE$1, |
| }; |
| Identifiers.getInheritedFactory = { |
| name: 'ɵɵgetInheritedFactory', |
| moduleName: CORE$1, |
| }; |
| // sanitization-related functions |
| Identifiers.sanitizeHtml = { name: 'ɵɵsanitizeHtml', moduleName: CORE$1 }; |
| Identifiers.sanitizeStyle = { name: 'ɵɵsanitizeStyle', moduleName: CORE$1 }; |
| Identifiers.defaultStyleSanitizer = { name: 'ɵɵdefaultStyleSanitizer', moduleName: CORE$1 }; |
| Identifiers.sanitizeResourceUrl = { name: 'ɵɵsanitizeResourceUrl', moduleName: CORE$1 }; |
| Identifiers.sanitizeScript = { name: 'ɵɵsanitizeScript', moduleName: CORE$1 }; |
| Identifiers.sanitizeUrl = { name: 'ɵɵsanitizeUrl', moduleName: CORE$1 }; |
| Identifiers.sanitizeUrlOrResourceUrl = { name: 'ɵɵsanitizeUrlOrResourceUrl', moduleName: CORE$1 }; |
| return Identifiers; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var $EOF = 0; |
| var $BSPACE = 8; |
| var $TAB = 9; |
| var $LF = 10; |
| var $VTAB = 11; |
| var $FF = 12; |
| var $CR = 13; |
| var $SPACE = 32; |
| var $BANG = 33; |
| var $DQ = 34; |
| var $HASH = 35; |
| var $$ = 36; |
| var $PERCENT = 37; |
| var $AMPERSAND = 38; |
| var $SQ = 39; |
| var $LPAREN = 40; |
| var $RPAREN = 41; |
| var $STAR = 42; |
| var $PLUS = 43; |
| var $COMMA = 44; |
| var $MINUS = 45; |
| var $PERIOD = 46; |
| var $SLASH = 47; |
| var $COLON = 58; |
| var $SEMICOLON = 59; |
| var $LT = 60; |
| var $EQ = 61; |
| var $GT = 62; |
| var $QUESTION = 63; |
| var $0 = 48; |
| var $7 = 55; |
| var $9 = 57; |
| var $A = 65; |
| var $E = 69; |
| var $F = 70; |
| var $X = 88; |
| var $Z = 90; |
| var $LBRACKET = 91; |
| var $BACKSLASH = 92; |
| var $RBRACKET = 93; |
| var $CARET = 94; |
| var $_ = 95; |
| var $a = 97; |
| var $b = 98; |
| var $e = 101; |
| var $f = 102; |
| var $n = 110; |
| var $r = 114; |
| var $t = 116; |
| var $u = 117; |
| var $v = 118; |
| var $x = 120; |
| var $z = 122; |
| var $LBRACE = 123; |
| var $BAR = 124; |
| var $RBRACE = 125; |
| var $NBSP = 160; |
| var $BT = 96; |
| function isWhitespace(code) { |
| return (code >= $TAB && code <= $SPACE) || (code == $NBSP); |
| } |
| function isDigit(code) { |
| return $0 <= code && code <= $9; |
| } |
| function isAsciiLetter(code) { |
| return code >= $a && code <= $z || code >= $A && code <= $Z; |
| } |
| function isAsciiHexDigit(code) { |
| return code >= $a && code <= $f || code >= $A && code <= $F || isDigit(code); |
| } |
| function isNewLine(code) { |
| return code === $LF || code === $CR; |
| } |
| function isOctalDigit(code) { |
| return $0 <= code && code <= $7; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var ParseLocation = /** @class */ (function () { |
| function ParseLocation(file, offset, line, col) { |
| this.file = file; |
| this.offset = offset; |
| this.line = line; |
| this.col = col; |
| } |
| ParseLocation.prototype.toString = function () { |
| return this.offset != null ? this.file.url + "@" + this.line + ":" + this.col : this.file.url; |
| }; |
| ParseLocation.prototype.moveBy = function (delta) { |
| var source = this.file.content; |
| var len = source.length; |
| var offset = this.offset; |
| var line = this.line; |
| var col = this.col; |
| while (offset > 0 && delta < 0) { |
| offset--; |
| delta++; |
| var ch = source.charCodeAt(offset); |
| if (ch == $LF) { |
| line--; |
| var priorLine = source.substr(0, offset - 1).lastIndexOf(String.fromCharCode($LF)); |
| col = priorLine > 0 ? offset - priorLine : offset; |
| } |
| else { |
| col--; |
| } |
| } |
| while (offset < len && delta > 0) { |
| var ch = source.charCodeAt(offset); |
| offset++; |
| delta--; |
| if (ch == $LF) { |
| line++; |
| col = 0; |
| } |
| else { |
| col++; |
| } |
| } |
| return new ParseLocation(this.file, offset, line, col); |
| }; |
| // Return the source around the location |
| // Up to `maxChars` or `maxLines` on each side of the location |
| ParseLocation.prototype.getContext = function (maxChars, maxLines) { |
| var content = this.file.content; |
| var startOffset = this.offset; |
| if (startOffset != null) { |
| if (startOffset > content.length - 1) { |
| startOffset = content.length - 1; |
| } |
| var endOffset = startOffset; |
| var ctxChars = 0; |
| var ctxLines = 0; |
| while (ctxChars < maxChars && startOffset > 0) { |
| startOffset--; |
| ctxChars++; |
| if (content[startOffset] == '\n') { |
| if (++ctxLines == maxLines) { |
| break; |
| } |
| } |
| } |
| ctxChars = 0; |
| ctxLines = 0; |
| while (ctxChars < maxChars && endOffset < content.length - 1) { |
| endOffset++; |
| ctxChars++; |
| if (content[endOffset] == '\n') { |
| if (++ctxLines == maxLines) { |
| break; |
| } |
| } |
| } |
| return { |
| before: content.substring(startOffset, this.offset), |
| after: content.substring(this.offset, endOffset + 1), |
| }; |
| } |
| return null; |
| }; |
| return ParseLocation; |
| }()); |
| var ParseSourceFile = /** @class */ (function () { |
| function ParseSourceFile(content, url) { |
| this.content = content; |
| this.url = url; |
| } |
| return ParseSourceFile; |
| }()); |
| var ParseSourceSpan = /** @class */ (function () { |
| function ParseSourceSpan(start, end, details) { |
| if (details === void 0) { details = null; } |
| this.start = start; |
| this.end = end; |
| this.details = details; |
| } |
| ParseSourceSpan.prototype.toString = function () { |
| return this.start.file.content.substring(this.start.offset, this.end.offset); |
| }; |
| return ParseSourceSpan; |
| }()); |
| (function (ParseErrorLevel) { |
| ParseErrorLevel[ParseErrorLevel["WARNING"] = 0] = "WARNING"; |
| ParseErrorLevel[ParseErrorLevel["ERROR"] = 1] = "ERROR"; |
| })(exports.ParseErrorLevel || (exports.ParseErrorLevel = {})); |
| var ParseError = /** @class */ (function () { |
| function ParseError(span, msg, level) { |
| if (level === void 0) { level = exports.ParseErrorLevel.ERROR; } |
| this.span = span; |
| this.msg = msg; |
| this.level = level; |
| } |
| ParseError.prototype.contextualMessage = function () { |
| var ctx = this.span.start.getContext(100, 3); |
| return ctx ? this.msg + " (\"" + ctx.before + "[" + exports.ParseErrorLevel[this.level] + " ->]" + ctx.after + "\")" : |
| this.msg; |
| }; |
| ParseError.prototype.toString = function () { |
| var details = this.span.details ? ", " + this.span.details : ''; |
| return this.contextualMessage() + ": " + this.span.start + details; |
| }; |
| return ParseError; |
| }()); |
| function typeSourceSpan(kind, type) { |
| var moduleUrl = identifierModuleUrl(type); |
| var sourceFileName = moduleUrl != null ? "in " + kind + " " + identifierName(type) + " in " + moduleUrl : |
| "in " + kind + " " + identifierName(type); |
| var sourceFile = new ParseSourceFile('', sourceFileName); |
| return new ParseSourceSpan(new ParseLocation(sourceFile, -1, -1, -1), new ParseLocation(sourceFile, -1, -1, -1)); |
| } |
| /** |
| * Generates Source Span object for a given R3 Type for JIT mode. |
| * |
| * @param kind Component or Directive. |
| * @param typeName name of the Component or Directive. |
| * @param sourceUrl reference to Component or Directive source. |
| * @returns instance of ParseSourceSpan that represent a given Component or Directive. |
| */ |
| function r3JitTypeSourceSpan(kind, typeName, sourceUrl) { |
| var sourceFileName = "in " + kind + " " + typeName + " in " + sourceUrl; |
| var sourceFile = new ParseSourceFile('', sourceFileName); |
| return new ParseSourceSpan(new ParseLocation(sourceFile, -1, -1, -1), new ParseLocation(sourceFile, -1, -1, -1)); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var Text = /** @class */ (function () { |
| function Text(value, sourceSpan) { |
| this.value = value; |
| this.sourceSpan = sourceSpan; |
| } |
| Text.prototype.visit = function (visitor) { return visitor.visitText(this); }; |
| return Text; |
| }()); |
| var BoundText = /** @class */ (function () { |
| function BoundText(value, sourceSpan, i18n) { |
| this.value = value; |
| this.sourceSpan = sourceSpan; |
| this.i18n = i18n; |
| } |
| BoundText.prototype.visit = function (visitor) { return visitor.visitBoundText(this); }; |
| return BoundText; |
| }()); |
| var TextAttribute = /** @class */ (function () { |
| function TextAttribute(name, value, sourceSpan, valueSpan, i18n) { |
| this.name = name; |
| this.value = value; |
| this.sourceSpan = sourceSpan; |
| this.valueSpan = valueSpan; |
| this.i18n = i18n; |
| } |
| TextAttribute.prototype.visit = function (visitor) { return visitor.visitTextAttribute(this); }; |
| return TextAttribute; |
| }()); |
| var BoundAttribute = /** @class */ (function () { |
| function BoundAttribute(name, type, securityContext, value, unit, sourceSpan, i18n) { |
| this.name = name; |
| this.type = type; |
| this.securityContext = securityContext; |
| this.value = value; |
| this.unit = unit; |
| this.sourceSpan = sourceSpan; |
| this.i18n = i18n; |
| } |
| BoundAttribute.fromBoundElementProperty = function (prop, i18n) { |
| return new BoundAttribute(prop.name, prop.type, prop.securityContext, prop.value, prop.unit, prop.sourceSpan, i18n); |
| }; |
| BoundAttribute.prototype.visit = function (visitor) { return visitor.visitBoundAttribute(this); }; |
| return BoundAttribute; |
| }()); |
| var BoundEvent = /** @class */ (function () { |
| function BoundEvent(name, type, handler, target, phase, sourceSpan, handlerSpan) { |
| this.name = name; |
| this.type = type; |
| this.handler = handler; |
| this.target = target; |
| this.phase = phase; |
| this.sourceSpan = sourceSpan; |
| this.handlerSpan = handlerSpan; |
| } |
| BoundEvent.fromParsedEvent = function (event) { |
| var target = event.type === 0 /* Regular */ ? event.targetOrPhase : null; |
| var phase = event.type === 1 /* Animation */ ? event.targetOrPhase : null; |
| return new BoundEvent(event.name, event.type, event.handler, target, phase, event.sourceSpan, event.handlerSpan); |
| }; |
| BoundEvent.prototype.visit = function (visitor) { return visitor.visitBoundEvent(this); }; |
| return BoundEvent; |
| }()); |
| var Element = /** @class */ (function () { |
| function Element(name, attributes, inputs, outputs, children, references, sourceSpan, startSourceSpan, endSourceSpan, i18n) { |
| this.name = name; |
| this.attributes = attributes; |
| this.inputs = inputs; |
| this.outputs = outputs; |
| this.children = children; |
| this.references = references; |
| this.sourceSpan = sourceSpan; |
| this.startSourceSpan = startSourceSpan; |
| this.endSourceSpan = endSourceSpan; |
| this.i18n = i18n; |
| // If the element is empty then the source span should include any closing tag |
| if (children.length === 0 && startSourceSpan && endSourceSpan) { |
| this.sourceSpan = new ParseSourceSpan(sourceSpan.start, endSourceSpan.end); |
| } |
| } |
| Element.prototype.visit = function (visitor) { return visitor.visitElement(this); }; |
| return Element; |
| }()); |
| var Template = /** @class */ (function () { |
| function Template(tagName, attributes, inputs, outputs, templateAttrs, children, references, variables, sourceSpan, startSourceSpan, endSourceSpan, i18n) { |
| this.tagName = tagName; |
| this.attributes = attributes; |
| this.inputs = inputs; |
| this.outputs = outputs; |
| this.templateAttrs = templateAttrs; |
| this.children = children; |
| this.references = references; |
| this.variables = variables; |
| this.sourceSpan = sourceSpan; |
| this.startSourceSpan = startSourceSpan; |
| this.endSourceSpan = endSourceSpan; |
| this.i18n = i18n; |
| } |
| Template.prototype.visit = function (visitor) { return visitor.visitTemplate(this); }; |
| return Template; |
| }()); |
| var Content = /** @class */ (function () { |
| function Content(selector, attributes, sourceSpan, i18n) { |
| this.selector = selector; |
| this.attributes = attributes; |
| this.sourceSpan = sourceSpan; |
| this.i18n = i18n; |
| } |
| Content.prototype.visit = function (visitor) { return visitor.visitContent(this); }; |
| return Content; |
| }()); |
| var Variable = /** @class */ (function () { |
| function Variable(name, value, sourceSpan) { |
| this.name = name; |
| this.value = value; |
| this.sourceSpan = sourceSpan; |
| } |
| Variable.prototype.visit = function (visitor) { return visitor.visitVariable(this); }; |
| return Variable; |
| }()); |
| var Reference = /** @class */ (function () { |
| function Reference(name, value, sourceSpan) { |
| this.name = name; |
| this.value = value; |
| this.sourceSpan = sourceSpan; |
| } |
| Reference.prototype.visit = function (visitor) { return visitor.visitReference(this); }; |
| return Reference; |
| }()); |
| var Icu = /** @class */ (function () { |
| function Icu(vars, placeholders, sourceSpan, i18n) { |
| this.vars = vars; |
| this.placeholders = placeholders; |
| this.sourceSpan = sourceSpan; |
| this.i18n = i18n; |
| } |
| Icu.prototype.visit = function (visitor) { return visitor.visitIcu(this); }; |
| return Icu; |
| }()); |
| function visitAll(visitor, nodes) { |
| var e_1, _a, e_2, _b; |
| var result = []; |
| if (visitor.visit) { |
| try { |
| for (var nodes_1 = __values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) { |
| var node = nodes_1_1.value; |
| var newNode = visitor.visit(node) || node.visit(visitor); |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) _a.call(nodes_1); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| } |
| else { |
| try { |
| for (var nodes_2 = __values(nodes), nodes_2_1 = nodes_2.next(); !nodes_2_1.done; nodes_2_1 = nodes_2.next()) { |
| var node = nodes_2_1.value; |
| var newNode = node.visit(visitor); |
| if (newNode) { |
| result.push(newNode); |
| } |
| } |
| } |
| catch (e_2_1) { e_2 = { error: e_2_1 }; } |
| finally { |
| try { |
| if (nodes_2_1 && !nodes_2_1.done && (_b = nodes_2.return)) _b.call(nodes_2); |
| } |
| finally { if (e_2) throw e_2.error; } |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var Message = /** @class */ (function () { |
| /** |
| * @param nodes message AST |
| * @param placeholders maps placeholder names to static content |
| * @param placeholderToMessage maps placeholder names to messages (used for nested ICU messages) |
| * @param meaning |
| * @param description |
| * @param id |
| */ |
| function Message(nodes, placeholders, placeholderToMessage, meaning, description, id) { |
| this.nodes = nodes; |
| this.placeholders = placeholders; |
| this.placeholderToMessage = placeholderToMessage; |
| this.meaning = meaning; |
| this.description = description; |
| this.id = id; |
| if (nodes.length) { |
| this.sources = [{ |
| filePath: nodes[0].sourceSpan.start.file.url, |
| startLine: nodes[0].sourceSpan.start.line + 1, |
| startCol: nodes[0].sourceSpan.start.col + 1, |
| endLine: nodes[nodes.length - 1].sourceSpan.end.line + 1, |
| endCol: nodes[0].sourceSpan.start.col + 1 |
| }]; |
| } |
| else { |
| this.sources = []; |
| } |
| } |
| return Message; |
| }()); |
| var Text$1 = /** @class */ (function () { |
| function Text(value, sourceSpan) { |
| this.value = value; |
| this.sourceSpan = sourceSpan; |
| } |
| Text.prototype.visit = function (visitor, context) { return visitor.visitText(this, context); }; |
| return Text; |
| }()); |
| // TODO(vicb): do we really need this node (vs an array) ? |
| var Container = /** @class */ (function () { |
| function Container(children, sourceSpan) { |
| this.children = children; |
| this.sourceSpan = sourceSpan; |
| } |
| Container.prototype.visit = function (visitor, context) { return visitor.visitContainer(this, context); }; |
| return Container; |
| }()); |
| var Icu$1 = /** @class */ (function () { |
| function Icu(expression, type, cases, sourceSpan) { |
| this.expression = expression; |
| this.type = type; |
| this.cases = cases; |
| this.sourceSpan = sourceSpan; |
| } |
| Icu.prototype.visit = function (visitor, context) { return visitor.visitIcu(this, context); }; |
| return Icu; |
| }()); |
| var TagPlaceholder = /** @class */ (function () { |
| function TagPlaceholder(tag, attrs, startName, closeName, children, isVoid, sourceSpan) { |
| this.tag = tag; |
| this.attrs = attrs; |
| this.startName = startName; |
| this.closeName = closeName; |
| this.children = children; |
| this.isVoid = isVoid; |
| this.sourceSpan = sourceSpan; |
| } |
| TagPlaceholder.prototype.visit = function (visitor, context) { return visitor.visitTagPlaceholder(this, context); }; |
| return TagPlaceholder; |
| }()); |
| var Placeholder = /** @class */ (function () { |
| function Placeholder(value, name, sourceSpan) { |
| this.value = value; |
| this.name = name; |
| this.sourceSpan = sourceSpan; |
| } |
| Placeholder.prototype.visit = function (visitor, context) { return visitor.visitPlaceholder(this, context); }; |
| return Placeholder; |
| }()); |
| var IcuPlaceholder = /** @class */ (function () { |
| function IcuPlaceholder(value, name, sourceSpan) { |
| this.value = value; |
| this.name = name; |
| this.sourceSpan = sourceSpan; |
| } |
| IcuPlaceholder.prototype.visit = function (visitor, context) { return visitor.visitIcuPlaceholder(this, context); }; |
| return IcuPlaceholder; |
| }()); |
| // Clone the AST |
| var CloneVisitor = /** @class */ (function () { |
| function CloneVisitor() { |
| } |
| CloneVisitor.prototype.visitText = function (text, context) { return new Text$1(text.value, text.sourceSpan); }; |
| CloneVisitor.prototype.visitContainer = function (container, context) { |
| var _this = this; |
| var children = container.children.map(function (n) { return n.visit(_this, context); }); |
| return new Container(children, container.sourceSpan); |
| }; |
| CloneVisitor.prototype.visitIcu = function (icu, context) { |
| var _this = this; |
| var cases = {}; |
| Object.keys(icu.cases).forEach(function (key) { return cases[key] = icu.cases[key].visit(_this, context); }); |
| var msg = new Icu$1(icu.expression, icu.type, cases, icu.sourceSpan); |
| msg.expressionPlaceholder = icu.expressionPlaceholder; |
| return msg; |
| }; |
| CloneVisitor.prototype.visitTagPlaceholder = function (ph, context) { |
| var _this = this; |
| var children = ph.children.map(function (n) { return n.visit(_this, context); }); |
| return new TagPlaceholder(ph.tag, ph.attrs, ph.startName, ph.closeName, children, ph.isVoid, ph.sourceSpan); |
| }; |
| CloneVisitor.prototype.visitPlaceholder = function (ph, context) { |
| return new Placeholder(ph.value, ph.name, ph.sourceSpan); |
| }; |
| CloneVisitor.prototype.visitIcuPlaceholder = function (ph, context) { |
| return new IcuPlaceholder(ph.value, ph.name, ph.sourceSpan); |
| }; |
| return CloneVisitor; |
| }()); |
| // Visit all the nodes recursively |
| var RecurseVisitor = /** @class */ (function () { |
| function RecurseVisitor() { |
| } |
| RecurseVisitor.prototype.visitText = function (text, context) { }; |
| RecurseVisitor.prototype.visitContainer = function (container, context) { |
| var _this = this; |
| container.children.forEach(function (child) { return child.visit(_this); }); |
| }; |
| RecurseVisitor.prototype.visitIcu = function (icu, context) { |
| var _this = this; |
| Object.keys(icu.cases).forEach(function (k) { icu.cases[k].visit(_this); }); |
| }; |
| RecurseVisitor.prototype.visitTagPlaceholder = function (ph, context) { |
| var _this = this; |
| ph.children.forEach(function (child) { return child.visit(_this); }); |
| }; |
| RecurseVisitor.prototype.visitPlaceholder = function (ph, context) { }; |
| RecurseVisitor.prototype.visitIcuPlaceholder = function (ph, context) { }; |
| return RecurseVisitor; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| function digest(message) { |
| return message.id || sha1(serializeNodes(message.nodes).join('') + ("[" + message.meaning + "]")); |
| } |
| function decimalDigest(message) { |
| if (message.id) { |
| return message.id; |
| } |
| var visitor = new _SerializerIgnoreIcuExpVisitor(); |
| var parts = message.nodes.map(function (a) { return a.visit(visitor, null); }); |
| return computeMsgId(parts.join(''), message.meaning); |
| } |
| /** |
| * Serialize the i18n ast to something xml-like in order to generate an UID. |
| * |
| * The visitor is also used in the i18n parser tests |
| * |
| * @internal |
| */ |
| var _SerializerVisitor = /** @class */ (function () { |
| function _SerializerVisitor() { |
| } |
| _SerializerVisitor.prototype.visitText = function (text, context) { return text.value; }; |
| _SerializerVisitor.prototype.visitContainer = function (container, context) { |
| var _this = this; |
| return "[" + container.children.map(function (child) { return child.visit(_this); }).join(', ') + "]"; |
| }; |
| _SerializerVisitor.prototype.visitIcu = function (icu, context) { |
| var _this = this; |
| var strCases = Object.keys(icu.cases).map(function (k) { return k + " {" + icu.cases[k].visit(_this) + "}"; }); |
| return "{" + icu.expression + ", " + icu.type + ", " + strCases.join(', ') + "}"; |
| }; |
| _SerializerVisitor.prototype.visitTagPlaceholder = function (ph, context) { |
| var _this = this; |
| return ph.isVoid ? |
| "<ph tag name=\"" + ph.startName + "\"/>" : |
| "<ph tag name=\"" + ph.startName + "\">" + ph.children.map(function (child) { return child.visit(_this); }).join(', ') + "</ph name=\"" + ph.closeName + "\">"; |
| }; |
| _SerializerVisitor.prototype.visitPlaceholder = function (ph, context) { |
| return ph.value ? "<ph name=\"" + ph.name + "\">" + ph.value + "</ph>" : "<ph name=\"" + ph.name + "\"/>"; |
| }; |
| _SerializerVisitor.prototype.visitIcuPlaceholder = function (ph, context) { |
| return "<ph icu name=\"" + ph.name + "\">" + ph.value.visit(this) + "</ph>"; |
| }; |
| return _SerializerVisitor; |
| }()); |
| var serializerVisitor = new _SerializerVisitor(); |
| function serializeNodes(nodes) { |
| return nodes.map(function (a) { return a.visit(serializerVisitor, null); }); |
| } |
| /** |
| * Serialize the i18n ast to something xml-like in order to generate an UID. |
| * |
| * Ignore the ICU expressions so that message IDs stays identical if only the expression changes. |
| * |
| * @internal |
| */ |
| var _SerializerIgnoreIcuExpVisitor = /** @class */ (function (_super) { |
| __extends(_SerializerIgnoreIcuExpVisitor, _super); |
| function _SerializerIgnoreIcuExpVisitor() { |
| return _super !== null && _super.apply(this, arguments) || this; |
| } |
| _SerializerIgnoreIcuExpVisitor.prototype.visitIcu = function (icu, context) { |
| var _this = this; |
| var strCases = Object.keys(icu.cases).map(function (k) { return k + " {" + icu.cases[k].visit(_this) + "}"; }); |
| // Do not take the expression into account |
| return "{" + icu.type + ", " + strCases.join(', ') + "}"; |
| }; |
| return _SerializerIgnoreIcuExpVisitor; |
| }(_SerializerVisitor)); |
| /** |
| * Compute the SHA1 of the given string |
| * |
| * see http://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf |
| * |
| * WARNING: this function has not been designed not tested with security in mind. |
| * DO NOT USE IT IN A SECURITY SENSITIVE CONTEXT. |
| */ |
| function sha1(str) { |
| var _a, _b; |
| var utf8 = utf8Encode(str); |
| var words32 = stringToWords32(utf8, Endian.Big); |
| var len = utf8.length * 8; |
| var w = new Array(80); |
| var _c = __read([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0], 5), a = _c[0], b = _c[1], c = _c[2], d = _c[3], e = _c[4]; |
| words32[len >> 5] |= 0x80 << (24 - len % 32); |
| words32[((len + 64 >> 9) << 4) + 15] = len; |
| for (var i = 0; i < words32.length; i += 16) { |
| var _d = __read([a, b, c, d, e], 5), h0 = _d[0], h1 = _d[1], h2 = _d[2], h3 = _d[3], h4 = _d[4]; |
| for (var j = 0; j < 80; j++) { |
| if (j < 16) { |
| w[j] = words32[i + j]; |
| } |
| else { |
| w[j] = rol32(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1); |
| } |
| var _e = __read(fk(j, b, c, d), 2), f = _e[0], k = _e[1]; |
| var temp = [rol32(a, 5), f, e, k, w[j]].reduce(add32); |
| _a = __read([d, c, rol32(b, 30), a, temp], 5), e = _a[0], d = _a[1], c = _a[2], b = _a[3], a = _a[4]; |
| } |
| _b = __read([add32(a, h0), add32(b, h1), add32(c, h2), add32(d, h3), add32(e, h4)], 5), a = _b[0], b = _b[1], c = _b[2], d = _b[3], e = _b[4]; |
| } |
| return byteStringToHexString(words32ToByteString([a, b, c, d, e])); |
| } |
| function fk(index, b, c, d) { |
| if (index < 20) { |
| return [(b & c) | (~b & d), 0x5a827999]; |
| } |
| if (index < 40) { |
| return [b ^ c ^ d, 0x6ed9eba1]; |
| } |
| if (index < 60) { |
| return [(b & c) | (b & d) | (c & d), 0x8f1bbcdc]; |
| } |
| return [b ^ c ^ d, 0xca62c1d6]; |
| } |
| /** |
| * Compute the fingerprint of the given string |
| * |
| * The output is 64 bit number encoded as a decimal string |
| * |
| * based on: |
| * https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/GoogleJsMessageIdGenerator.java |
| */ |
| function fingerprint(str) { |
| var utf8 = utf8Encode(str); |
| var _a = __read([hash32(utf8, 0), hash32(utf8, 102072)], 2), hi = _a[0], lo = _a[1]; |
| if (hi == 0 && (lo == 0 || lo == 1)) { |
| hi = hi ^ 0x130f9bef; |
| lo = lo ^ -0x6b5f56d8; |
| } |
| return [hi, lo]; |
| } |
| function computeMsgId(msg, meaning) { |
| var _a; |
| var _b = __read(fingerprint(msg), 2), hi = _b[0], lo = _b[1]; |
| if (meaning) { |
| var _c = __read(fingerprint(meaning), 2), him = _c[0], lom = _c[1]; |
| _a = __read(add64(rol64([hi, lo], 1), [him, lom]), 2), hi = _a[0], lo = _a[1]; |
| } |
| return byteStringToDecString(words32ToByteString([hi & 0x7fffffff, lo])); |
| } |
| function hash32(str, c) { |
| var _a; |
| var _b = __read([0x9e3779b9, 0x9e3779b9], 2), a = _b[0], b = _b[1]; |
| var i; |
| var len = str.length; |
| for (i = 0; i + 12 <= len; i += 12) { |
| a = add32(a, wordAt(str, i, Endian.Little)); |
| b = add32(b, wordAt(str, i + 4, Endian.Little)); |
| c = add32(c, wordAt(str, i + 8, Endian.Little)); |
| _a = __read(mix([a, b, c]), 3), a = _a[0], b = _a[1], c = _a[2]; |
| } |
| a = add32(a, wordAt(str, i, Endian.Little)); |
| b = add32(b, wordAt(str, i + 4, Endian.Little)); |
| // the first byte of c is reserved for the length |
| c = add32(c, len); |
| c = add32(c, wordAt(str, i + 8, Endian.Little) << 8); |
| return mix([a, b, c])[2]; |
| } |
| // clang-format off |
| function mix(_a) { |
| var _b = __read(_a, 3), a = _b[0], b = _b[1], c = _b[2]; |
| a = sub32(a, b); |
| a = sub32(a, c); |
| a ^= c >>> 13; |
| b = sub32(b, c); |
| b = sub32(b, a); |
| b ^= a << 8; |
| c = sub32(c, a); |
| c = sub32(c, b); |
| c ^= b >>> 13; |
| a = sub32(a, b); |
| a = sub32(a, c); |
| a ^= c >>> 12; |
| b = sub32(b, c); |
| b = sub32(b, a); |
| b ^= a << 16; |
| c = sub32(c, a); |
| c = sub32(c, b); |
| c ^= b >>> 5; |
| a = sub32(a, b); |
| a = sub32(a, c); |
| a ^= c >>> 3; |
| b = sub32(b, c); |
| b = sub32(b, a); |
| b ^= a << 10; |
| c = sub32(c, a); |
| c = sub32(c, b); |
| c ^= b >>> 15; |
| return [a, b, c]; |
| } |
| // clang-format on |
| // Utils |
| var Endian; |
| (function (Endian) { |
| Endian[Endian["Little"] = 0] = "Little"; |
| Endian[Endian["Big"] = 1] = "Big"; |
| })(Endian || (Endian = {})); |
| function add32(a, b) { |
| return add32to64(a, b)[1]; |
| } |
| function add32to64(a, b) { |
| var low = (a & 0xffff) + (b & 0xffff); |
| var high = (a >>> 16) + (b >>> 16) + (low >>> 16); |
| return [high >>> 16, (high << 16) | (low & 0xffff)]; |
| } |
| function add64(_a, _b) { |
| var _c = __read(_a, 2), ah = _c[0], al = _c[1]; |
| var _d = __read(_b, 2), bh = _d[0], bl = _d[1]; |
| var _e = __read(add32to64(al, bl), 2), carry = _e[0], l = _e[1]; |
| var h = add32(add32(ah, bh), carry); |
| return [h, l]; |
| } |
| function sub32(a, b) { |
| var low = (a & 0xffff) - (b & 0xffff); |
| var high = (a >> 16) - (b >> 16) + (low >> 16); |
| return (high << 16) | (low & 0xffff); |
| } |
| // Rotate a 32b number left `count` position |
| function rol32(a, count) { |
| return (a << count) | (a >>> (32 - count)); |
| } |
| // Rotate a 64b number left `count` position |
| function rol64(_a, count) { |
| var _b = __read(_a, 2), hi = _b[0], lo = _b[1]; |
| var h = (hi << count) | (lo >>> (32 - count)); |
| var l = (lo << count) | (hi >>> (32 - count)); |
| return [h, l]; |
| } |
| function stringToWords32(str, endian) { |
| var words32 = Array((str.length + 3) >>> 2); |
| for (var i = 0; i < words32.length; i++) { |
| words32[i] = wordAt(str, i * 4, endian); |
| } |
| return words32; |
| } |
| function byteAt(str, index) { |
| return index >= str.length ? 0 : str.charCodeAt(index) & 0xff; |
| } |
| function wordAt(str, index, endian) { |
| var word = 0; |
| if (endian === Endian.Big) { |
| for (var i = 0; i < 4; i++) { |
| word += byteAt(str, index + i) << (24 - 8 * i); |
| } |
| } |
| else { |
| for (var i = 0; i < 4; i++) { |
| word += byteAt(str, index + i) << 8 * i; |
| } |
| } |
| return word; |
| } |
| function words32ToByteString(words32) { |
| return words32.reduce(function (str, word) { return str + word32ToByteString(word); }, ''); |
| } |
| function word32ToByteString(word) { |
| var str = ''; |
| for (var i = 0; i < 4; i++) { |
| str += String.fromCharCode((word >>> 8 * (3 - i)) & 0xff); |
| } |
| return str; |
| } |
| function byteStringToHexString(str) { |
| var hex = ''; |
| for (var i = 0; i < str.length; i++) { |
| var b = byteAt(str, i); |
| hex += (b >>> 4).toString(16) + (b & 0x0f).toString(16); |
| } |
| return hex.toLowerCase(); |
| } |
| // based on http://www.danvk.org/hex2dec.html (JS can not handle more than 56b) |
| function byteStringToDecString(str) { |
| var decimal = ''; |
| var toThePower = '1'; |
| for (var i = str.length - 1; i >= 0; i--) { |
| decimal = addBigInt(decimal, numberTimesBigInt(byteAt(str, i), toThePower)); |
| toThePower = numberTimesBigInt(256, toThePower); |
| } |
| return decimal.split('').reverse().join(''); |
| } |
| // x and y decimal, lowest significant digit first |
| function addBigInt(x, y) { |
| var sum = ''; |
| var len = Math.max(x.length, y.length); |
| for (var i = 0, carry = 0; i < len || carry; i++) { |
| var tmpSum = carry + +(x[i] || 0) + +(y[i] || 0); |
| if (tmpSum >= 10) { |
| carry = 1; |
| sum += tmpSum - 10; |
| } |
| else { |
| carry = 0; |
| sum += tmpSum; |
| } |
| } |
| return sum; |
| } |
| function numberTimesBigInt(num, b) { |
| var product = ''; |
| var bToThePower = b; |
| for (; num !== 0; num = num >>> 1) { |
| if (num & 1) |
| product = addBigInt(product, bToThePower); |
| bToThePower = addBigInt(bToThePower, bToThePower); |
| } |
| return product; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var Serializer = /** @class */ (function () { |
| function Serializer() { |
| } |
| // Creates a name mapper, see `PlaceholderMapper` |
| // Returning `null` means that no name mapping is used. |
| Serializer.prototype.createNameMapper = function (message) { return null; }; |
| return Serializer; |
| }()); |
| /** |
| * A simple mapper that take a function to transform an internal name to a public name |
| */ |
| var SimplePlaceholderMapper = /** @class */ (function (_super) { |
| __extends(SimplePlaceholderMapper, _super); |
| // create a mapping from the message |
| function SimplePlaceholderMapper(message, mapName) { |
| var _this = _super.call(this) || this; |
| _this.mapName = mapName; |
| _this.internalToPublic = {}; |
| _this.publicToNextId = {}; |
| _this.publicToInternal = {}; |
| message.nodes.forEach(function (node) { return node.visit(_this); }); |
| return _this; |
| } |
| SimplePlaceholderMapper.prototype.toPublicName = function (internalName) { |
| return this.internalToPublic.hasOwnProperty(internalName) ? |
| this.internalToPublic[internalName] : |
| null; |
| }; |
| SimplePlaceholderMapper.prototype.toInternalName = function (publicName) { |
| return this.publicToInternal.hasOwnProperty(publicName) ? this.publicToInternal[publicName] : |
| null; |
| }; |
| SimplePlaceholderMapper.prototype.visitText = function (text, context) { return null; }; |
| SimplePlaceholderMapper.prototype.visitTagPlaceholder = function (ph, context) { |
| this.visitPlaceholderName(ph.startName); |
| _super.prototype.visitTagPlaceholder.call(this, ph, context); |
| this.visitPlaceholderName(ph.closeName); |
| }; |
| SimplePlaceholderMapper.prototype.visitPlaceholder = function (ph, context) { this.visitPlaceholderName(ph.name); }; |
| SimplePlaceholderMapper.prototype.visitIcuPlaceholder = function (ph, context) { |
| this.visitPlaceholderName(ph.name); |
| }; |
| // XMB placeholders could only contains A-Z, 0-9 and _ |
| SimplePlaceholderMapper.prototype.visitPlaceholderName = function (internalName) { |
| if (!internalName || this.internalToPublic.hasOwnProperty(internalName)) { |
| return; |
| } |
| var publicName = this.mapName(internalName); |
| if (this.publicToInternal.hasOwnProperty(publicName)) { |
| // Create a new XMB when it has already been used |
| var nextId = this.publicToNextId[publicName]; |
| this.publicToNextId[publicName] = nextId + 1; |
| publicName = publicName + "_" + nextId; |
| } |
| else { |
| this.publicToNextId[publicName] = 1; |
| } |
| this.internalToPublic[internalName] = publicName; |
| this.publicToInternal[publicName] = internalName; |
| }; |
| return SimplePlaceholderMapper; |
| }(RecurseVisitor)); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var _Visitor = /** @class */ (function () { |
| function _Visitor() { |
| } |
| _Visitor.prototype.visitTag = function (tag) { |
| var _this = this; |
| var strAttrs = this._serializeAttributes(tag.attrs); |
| if (tag.children.length == 0) { |
| return "<" + tag.name + strAttrs + "/>"; |
| } |
| var strChildren = tag.children.map(function (node) { return node.visit(_this); }); |
| return "<" + tag.name + strAttrs + ">" + strChildren.join('') + "</" + tag.name + ">"; |
| }; |
| _Visitor.prototype.visitText = function (text) { return text.value; }; |
| _Visitor.prototype.visitDeclaration = function (decl) { |
| return "<?xml" + this._serializeAttributes(decl.attrs) + " ?>"; |
| }; |
| _Visitor.prototype._serializeAttributes = function (attrs) { |
| var strAttrs = Object.keys(attrs).map(function (name) { return name + "=\"" + attrs[name] + "\""; }).join(' '); |
| return strAttrs.length > 0 ? ' ' + strAttrs : ''; |
| }; |
| _Visitor.prototype.visitDoctype = function (doctype) { |
| return "<!DOCTYPE " + doctype.rootTag + " [\n" + doctype.dtd + "\n]>"; |
| }; |
| return _Visitor; |
| }()); |
| var _visitor = new _Visitor(); |
| function serialize(nodes) { |
| return nodes.map(function (node) { return node.visit(_visitor); }).join(''); |
| } |
| var Declaration = /** @class */ (function () { |
| function Declaration(unescapedAttrs) { |
| var _this = this; |
| this.attrs = {}; |
| Object.keys(unescapedAttrs).forEach(function (k) { |
| _this.attrs[k] = escapeXml(unescapedAttrs[k]); |
| }); |
| } |
| Declaration.prototype.visit = function (visitor) { return visitor.visitDeclaration(this); }; |
| return Declaration; |
| }()); |
| var Doctype = /** @class */ (function () { |
| function Doctype(rootTag, dtd) { |
| this.rootTag = rootTag; |
| this.dtd = dtd; |
| } |
| Doctype.prototype.visit = function (visitor) { return visitor.visitDoctype(this); }; |
| return Doctype; |
| }()); |
| var Tag = /** @class */ (function () { |
| function Tag(name, unescapedAttrs, children) { |
| var _this = this; |
| if (unescapedAttrs === void 0) { unescapedAttrs = {}; } |
| if (children === void 0) { children = []; } |
| this.name = name; |
| this.children = children; |
| this.attrs = {}; |
| Object.keys(unescapedAttrs).forEach(function (k) { |
| _this.attrs[k] = escapeXml(unescapedAttrs[k]); |
| }); |
| } |
| Tag.prototype.visit = function (visitor) { return visitor.visitTag(this); }; |
| return Tag; |
| }()); |
| var Text$2 = /** @class */ (function () { |
| function Text(unescapedValue) { |
| this.value = escapeXml(unescapedValue); |
| } |
| Text.prototype.visit = function (visitor) { return visitor.visitText(this); }; |
| return Text; |
| }()); |
| var CR = /** @class */ (function (_super) { |
| __extends(CR, _super); |
| function CR(ws) { |
| if (ws === void 0) { ws = 0; } |
| return _super.call(this, "\n" + new Array(ws + 1).join(' ')) || this; |
| } |
| return CR; |
| }(Text$2)); |
| var _ESCAPED_CHARS = [ |
| [/&/g, '&'], |
| [/"/g, '"'], |
| [/'/g, '''], |
| [/</g, '<'], |
| [/>/g, '>'], |
| ]; |
| // Escape `_ESCAPED_CHARS` characters in the given text with encoded entities |
| function escapeXml(text) { |
| return _ESCAPED_CHARS.reduce(function (text, entry) { return text.replace(entry[0], entry[1]); }, text); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var _MESSAGES_TAG = 'messagebundle'; |
| var _MESSAGE_TAG = 'msg'; |
| var _PLACEHOLDER_TAG = 'ph'; |
| var _EXAMPLE_TAG = 'ex'; |
| var _SOURCE_TAG = 'source'; |
| var _DOCTYPE = "<!ELEMENT messagebundle (msg)*>\n<!ATTLIST messagebundle class CDATA #IMPLIED>\n\n<!ELEMENT msg (#PCDATA|ph|source)*>\n<!ATTLIST msg id CDATA #IMPLIED>\n<!ATTLIST msg seq CDATA #IMPLIED>\n<!ATTLIST msg name CDATA #IMPLIED>\n<!ATTLIST msg desc CDATA #IMPLIED>\n<!ATTLIST msg meaning CDATA #IMPLIED>\n<!ATTLIST msg obsolete (obsolete) #IMPLIED>\n<!ATTLIST msg xml:space (default|preserve) \"default\">\n<!ATTLIST msg is_hidden CDATA #IMPLIED>\n\n<!ELEMENT source (#PCDATA)>\n\n<!ELEMENT ph (#PCDATA|ex)*>\n<!ATTLIST ph name CDATA #REQUIRED>\n\n<!ELEMENT ex (#PCDATA)>"; |
| var Xmb = /** @class */ (function (_super) { |
| __extends(Xmb, _super); |
| function Xmb() { |
| return _super !== null && _super.apply(this, arguments) || this; |
| } |
| Xmb.prototype.write = function (messages, locale) { |
| var exampleVisitor = new ExampleVisitor(); |
| var visitor = new _Visitor$1(); |
| var rootNode = new Tag(_MESSAGES_TAG); |
| messages.forEach(function (message) { |
| var attrs = { id: message.id }; |
| if (message.description) { |
| attrs['desc'] = message.description; |
| } |
| if (message.meaning) { |
| attrs['meaning'] = message.meaning; |
| } |
| var sourceTags = []; |
| message.sources.forEach(function (source) { |
| sourceTags.push(new Tag(_SOURCE_TAG, {}, [ |
| new Text$2(source.filePath + ":" + source.startLine + (source.endLine !== source.startLine ? ',' + source.endLine : '')) |
| ])); |
| }); |
| rootNode.children.push(new CR(2), new Tag(_MESSAGE_TAG, attrs, __spread(sourceTags, visitor.serialize(message.nodes)))); |
| }); |
| rootNode.children.push(new CR()); |
| return serialize([ |
| new Declaration({ version: '1.0', encoding: 'UTF-8' }), |
| new CR(), |
| new Doctype(_MESSAGES_TAG, _DOCTYPE), |
| new CR(), |
| exampleVisitor.addDefaultExamples(rootNode), |
| new CR(), |
| ]); |
| }; |
| Xmb.prototype.load = function (content, url) { |
| throw new Error('Unsupported'); |
| }; |
| Xmb.prototype.digest = function (message) { return digest$1(message); }; |
| Xmb.prototype.createNameMapper = function (message) { |
| return new SimplePlaceholderMapper(message, toPublicName); |
| }; |
| return Xmb; |
| }(Serializer)); |
| var _Visitor$1 = /** @class */ (function () { |
| function _Visitor() { |
| } |
| _Visitor.prototype.visitText = function (text, context) { return [new Text$2(text.value)]; }; |
| _Visitor.prototype.visitContainer = function (container, context) { |
| var _this = this; |
| var nodes = []; |
| container.children.forEach(function (node) { return nodes.push.apply(nodes, __spread(node.visit(_this))); }); |
| return nodes; |
| }; |
| _Visitor.prototype.visitIcu = function (icu, context) { |
| var _this = this; |
| var nodes = [new Text$2("{" + icu.expressionPlaceholder + ", " + icu.type + ", ")]; |
| Object.keys(icu.cases).forEach(function (c) { |
| nodes.push.apply(nodes, __spread([new Text$2(c + " {")], icu.cases[c].visit(_this), [new Text$2("} ")])); |
| }); |
| nodes.push(new Text$2("}")); |
| return nodes; |
| }; |
| _Visitor.prototype.visitTagPlaceholder = function (ph, context) { |
| var startTagAsText = new Text$2("<" + ph.tag + ">"); |
| var startEx = new Tag(_EXAMPLE_TAG, {}, [startTagAsText]); |
| // TC requires PH to have a non empty EX, and uses the text node to show the "original" value. |
| var startTagPh = new Tag(_PLACEHOLDER_TAG, { name: ph.startName }, [startEx, startTagAsText]); |
| if (ph.isVoid) { |
| // void tags have no children nor closing tags |
| return [startTagPh]; |
| } |
| var closeTagAsText = new Text$2("</" + ph.tag + ">"); |
| var closeEx = new Tag(_EXAMPLE_TAG, {}, [closeTagAsText]); |
| // TC requires PH to have a non empty EX, and uses the text node to show the "original" value. |
| var closeTagPh = new Tag(_PLACEHOLDER_TAG, { name: ph.closeName }, [closeEx, closeTagAsText]); |
| return __spread([startTagPh], this.serialize(ph.children), [closeTagPh]); |
| }; |
| _Visitor.prototype.visitPlaceholder = function (ph, context) { |
| var interpolationAsText = new Text$2("{{" + ph.value + "}}"); |
| // Example tag needs to be not-empty for TC. |
| var exTag = new Tag(_EXAMPLE_TAG, {}, [interpolationAsText]); |
| return [ |
| // TC requires PH to have a non empty EX, and uses the text node to show the "original" value. |
| new Tag(_PLACEHOLDER_TAG, { name: ph.name }, [exTag, interpolationAsText]) |
| ]; |
| }; |
| _Visitor.prototype.visitIcuPlaceholder = function (ph, context) { |
| var icuExpression = ph.value.expression; |
| var icuType = ph.value.type; |
| var icuCases = Object.keys(ph.value.cases).map(function (value) { return value + ' {...}'; }).join(' '); |
| var icuAsText = new Text$2("{" + icuExpression + ", " + icuType + ", " + icuCases + "}"); |
| var exTag = new Tag(_EXAMPLE_TAG, {}, [icuAsText]); |
| return [ |
| // TC requires PH to have a non empty EX, and uses the text node to show the "original" value. |
| new Tag(_PLACEHOLDER_TAG, { name: ph.name }, [exTag, icuAsText]) |
| ]; |
| }; |
| _Visitor.prototype.serialize = function (nodes) { |
| var _this = this; |
| return [].concat.apply([], __spread(nodes.map(function (node) { return node.visit(_this); }))); |
| }; |
| return _Visitor; |
| }()); |
| function digest$1(message) { |
| return decimalDigest(message); |
| } |
| // TC requires at least one non-empty example on placeholders |
| var ExampleVisitor = /** @class */ (function () { |
| function ExampleVisitor() { |
| } |
| ExampleVisitor.prototype.addDefaultExamples = function (node) { |
| node.visit(this); |
| return node; |
| }; |
| ExampleVisitor.prototype.visitTag = function (tag) { |
| var _this = this; |
| if (tag.name === _PLACEHOLDER_TAG) { |
| if (!tag.children || tag.children.length == 0) { |
| var exText = new Text$2(tag.attrs['name'] || '...'); |
| tag.children = [new Tag(_EXAMPLE_TAG, {}, [exText])]; |
| } |
| } |
| else if (tag.children) { |
| tag.children.forEach(function (node) { return node.visit(_this); }); |
| } |
| }; |
| ExampleVisitor.prototype.visitText = function (text) { }; |
| ExampleVisitor.prototype.visitDeclaration = function (decl) { }; |
| ExampleVisitor.prototype.visitDoctype = function (doctype) { }; |
| return ExampleVisitor; |
| }()); |
| // XMB/XTB placeholders can only contain A-Z, 0-9 and _ |
| function toPublicName(internalName) { |
| return internalName.toUpperCase().replace(/[^A-Z0-9_]/g, '_'); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| function mapLiteral(obj, quoted) { |
| if (quoted === void 0) { quoted = false; } |
| return literalMap(Object.keys(obj).map(function (key) { return ({ |
| key: key, |
| quoted: quoted, |
| value: obj[key], |
| }); })); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /* Closure variables holding messages must be named `MSG_[A-Z0-9]+` */ |
| var CLOSURE_TRANSLATION_PREFIX = 'MSG_'; |
| /* Prefix for non-`goog.getMsg` i18n-related vars */ |
| var TRANSLATION_PREFIX = 'I18N_'; |
| /** Closure uses `goog.getMsg(message)` to lookup translations */ |
| var GOOG_GET_MSG = 'goog.getMsg'; |
| /** Name of the global variable that is used to determine if we use Closure translations or not */ |
| var NG_I18N_CLOSURE_MODE = 'ngI18nClosureMode'; |
| /** I18n separators for metadata **/ |
| var I18N_MEANING_SEPARATOR = '|'; |
| var I18N_ID_SEPARATOR = '@@'; |
| /** Name of the i18n attributes **/ |
| var I18N_ATTR = 'i18n'; |
| var I18N_ATTR_PREFIX = 'i18n-'; |
| /** Prefix of var expressions used in ICUs */ |
| var I18N_ICU_VAR_PREFIX = 'VAR_'; |
| /** Prefix of ICU expressions for post processing */ |
| var I18N_ICU_MAPPING_PREFIX = 'I18N_EXP_'; |
| /** Placeholder wrapper for i18n expressions **/ |
| var I18N_PLACEHOLDER_SYMBOL = '�'; |
| function i18nTranslationToDeclStmt(variable$1, closureVar, message, meta, params) { |
| var statements = []; |
| // var I18N_X; |
| statements.push(new DeclareVarStmt(variable$1.name, undefined, INFERRED_TYPE, null, variable$1.sourceSpan)); |
| var args = [literal(message)]; |
| if (params && Object.keys(params).length) { |
| args.push(mapLiteral(params, true)); |
| } |
| // Closure JSDoc comments |
| var docStatements = i18nMetaToDocStmt(meta); |
| var thenStatements = docStatements ? [docStatements] : []; |
| var googFnCall = variable(GOOG_GET_MSG).callFn(args); |
| // const MSG_... = goog.getMsg(..); |
| thenStatements.push(closureVar.set(googFnCall).toConstDecl()); |
| // I18N_X = MSG_...; |
| thenStatements.push(new ExpressionStatement(variable$1.set(closureVar))); |
| var localizeFnCall = importExpr(Identifiers$1.i18nLocalize).callFn(args); |
| // I18N_X = i18nLocalize(...); |
| var elseStatements = [new ExpressionStatement(variable$1.set(localizeFnCall))]; |
| // if(ngI18nClosureMode) { ... } else { ... } |
| statements.push(ifStmt(variable(NG_I18N_CLOSURE_MODE), thenStatements, elseStatements)); |
| return statements; |
| } |
| // Converts i18n meta information for a message (id, description, meaning) |
| // to a JsDoc statement formatted as expected by the Closure compiler. |
| function i18nMetaToDocStmt(meta) { |
| var tags = []; |
| if (meta.description) { |
| tags.push({ tagName: "desc" /* Desc */, text: meta.description }); |
| } |
| if (meta.meaning) { |
| tags.push({ tagName: "meaning" /* Meaning */, text: meta.meaning }); |
| } |
| return tags.length == 0 ? null : new JSDocCommentStmt(tags); |
| } |
| function isI18nAttribute(name) { |
| return name === I18N_ATTR || name.startsWith(I18N_ATTR_PREFIX); |
| } |
| function isI18nRootNode(meta) { |
| return meta instanceof Message; |
| } |
| function isSingleI18nIcu(meta) { |
| return isI18nRootNode(meta) && meta.nodes.length === 1 && meta.nodes[0] instanceof Icu$1; |
| } |
| function hasI18nAttrs(element) { |
| return element.attrs.some(function (attr) { return isI18nAttribute(attr.name); }); |
| } |
| function metaFromI18nMessage(message, id) { |
| if (id === void 0) { id = null; } |
| return { |
| id: typeof id === 'string' ? id : message.id || '', |
| meaning: message.meaning || '', |
| description: message.description || '' |
| }; |
| } |
| function icuFromI18nMessage(message) { |
| return message.nodes[0]; |
| } |
| function wrapI18nPlaceholder(content, contextId) { |
| if (contextId === void 0) { contextId = 0; } |
| var blockId = contextId > 0 ? ":" + contextId : ''; |
| return "" + I18N_PLACEHOLDER_SYMBOL + content + blockId + I18N_PLACEHOLDER_SYMBOL; |
| } |
| function assembleI18nBoundString(strings, bindingStartIndex, contextId) { |
| if (bindingStartIndex === void 0) { bindingStartIndex = 0; } |
| if (contextId === void 0) { contextId = 0; } |
| if (!strings.length) |
| return ''; |
| var acc = ''; |
| var lastIdx = strings.length - 1; |
| for (var i = 0; i < lastIdx; i++) { |
| acc += "" + strings[i] + wrapI18nPlaceholder(bindingStartIndex + i, contextId); |
| } |
| acc += strings[lastIdx]; |
| return acc; |
| } |
| function getSeqNumberGenerator(startsAt) { |
| if (startsAt === void 0) { startsAt = 0; } |
| var current = startsAt; |
| return function () { return current++; }; |
| } |
| function placeholdersToParams(placeholders) { |
| var params = {}; |
| placeholders.forEach(function (values, key) { |
| params[key] = literal(values.length > 1 ? "[" + values.join('|') + "]" : values[0]); |
| }); |
| return params; |
| } |
| function updatePlaceholderMap(map, name) { |
| var values = []; |
| for (var _i = 2; _i < arguments.length; _i++) { |
| values[_i - 2] = arguments[_i]; |
| } |
| var current = map.get(name) || []; |
| current.push.apply(current, __spread(values)); |
| map.set(name, current); |
| } |
| function assembleBoundTextPlaceholders(meta, bindingStartIndex, contextId) { |
| if (bindingStartIndex === void 0) { bindingStartIndex = 0; } |
| if (contextId === void 0) { contextId = 0; } |
| var startIdx = bindingStartIndex; |
| var placeholders = new Map(); |
| var node = meta instanceof Message ? meta.nodes.find(function (node) { return node instanceof Container; }) : meta; |
| if (node) { |
| node |
| .children.filter(function (child) { return child instanceof Placeholder; }) |
| .forEach(function (child, idx) { |
| var content = wrapI18nPlaceholder(startIdx + idx, contextId); |
| updatePlaceholderMap(placeholders, child.name, content); |
| }); |
| } |
| return placeholders; |
| } |
| function findIndex(items, callback) { |
| for (var i = 0; i < items.length; i++) { |
| if (callback(items[i])) { |
| return i; |
| } |
| } |
| return -1; |
| } |
| /** |
| * Parses i18n metas like: |
| * - "@@id", |
| * - "description[@@id]", |
| * - "meaning|description[@@id]" |
| * and returns an object with parsed output. |
| * |
| * @param meta String that represents i18n meta |
| * @returns Object with id, meaning and description fields |
| */ |
| function parseI18nMeta(meta) { |
| var _a, _b; |
| var id; |
| var meaning; |
| var description; |
| if (meta) { |
| var idIndex = meta.indexOf(I18N_ID_SEPARATOR); |
| var descIndex = meta.indexOf(I18N_MEANING_SEPARATOR); |
| var meaningAndDesc = void 0; |
| _a = __read((idIndex > -1) ? [meta.slice(0, idIndex), meta.slice(idIndex + 2)] : [meta, ''], 2), meaningAndDesc = _a[0], id = _a[1]; |
| _b = __read((descIndex > -1) ? |
| [meaningAndDesc.slice(0, descIndex), meaningAndDesc.slice(descIndex + 1)] : |
| ['', meaningAndDesc], 2), meaning = _b[0], description = _b[1]; |
| } |
| return { id: id, meaning: meaning, description: description }; |
| } |
| /** |
| * Converts internal placeholder names to public-facing format |
| * (for example to use in goog.getMsg call). |
| * Example: `START_TAG_DIV_1` is converted to `startTagDiv_1`. |
| * |
| * @param name The placeholder name that should be formatted |
| * @returns Formatted placeholder name |
| */ |
| function formatI18nPlaceholderName(name) { |
| var chunks = toPublicName(name).split('_'); |
| if (chunks.length === 1) { |
| // if no "_" found - just lowercase the value |
| return name.toLowerCase(); |
| } |
| var postfix; |
| // eject last element if it's a number |
| if (/^\d+$/.test(chunks[chunks.length - 1])) { |
| postfix = chunks.pop(); |
| } |
| var raw = chunks.shift().toLowerCase(); |
| if (chunks.length) { |
| raw += chunks.map(function (c) { return c.charAt(0).toUpperCase() + c.slice(1).toLowerCase(); }).join(''); |
| } |
| return postfix ? raw + "_" + postfix : raw; |
| } |
| /** |
| * Generates a prefix for translation const name. |
| * |
| * @param extra Additional local prefix that should be injected into translation var name |
| * @returns Complete translation const prefix |
| */ |
| function getTranslationConstPrefix(extra) { |
| return ("" + CLOSURE_TRANSLATION_PREFIX + extra).toUpperCase(); |
| } |
| /** |
| * Generates translation declaration statements. |
| * |
| * @param variable Translation value reference |
| * @param closureVar Variable for Closure `goog.getMsg` calls |
| * @param message Text message to be translated |
| * @param meta Object that contains meta information (id, meaning and description) |
| * @param params Object with placeholders key-value pairs |
| * @param transformFn Optional transformation (post processing) function reference |
| * @returns Array of Statements that represent a given translation |
| */ |
| function getTranslationDeclStmts(variable, closureVar, message, meta, params, transformFn) { |
| if (params === void 0) { params = {}; } |
| var statements = []; |
| statements.push.apply(statements, __spread(i18nTranslationToDeclStmt(variable, closureVar, message, meta, params))); |
| if (transformFn) { |
| statements.push(new ExpressionStatement(variable.set(transformFn(variable)))); |
| } |
| return statements; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * Checks whether an object key contains potentially unsafe chars, thus the key should be wrapped in |
| * quotes. Note: we do not wrap all keys into quotes, as it may have impact on minification and may |
| * bot work in some cases when object keys are mangled by minifier. |
| * |
| * TODO(FW-1136): this is a temporary solution, we need to come up with a better way of working with |
| * inputs that contain potentially unsafe chars. |
| */ |
| var UNSAFE_OBJECT_KEY_NAME_REGEXP = /[-.]/; |
| /** Name of the temporary to use during data binding */ |
| var TEMPORARY_NAME = '_t'; |
| /** Name of the context parameter passed into a template function */ |
| var CONTEXT_NAME = 'ctx'; |
| /** Name of the RenderFlag passed into a template function */ |
| var RENDER_FLAGS = 'rf'; |
| /** The prefix reference variables */ |
| var REFERENCE_PREFIX = '_r'; |
| /** The name of the implicit context reference */ |
| var IMPLICIT_REFERENCE = '$implicit'; |
| /** Non bindable attribute name **/ |
| var NON_BINDABLE_ATTR = 'ngNonBindable'; |
| /** |
| * Creates an allocator for a temporary variable. |
| * |
| * A variable declaration is added to the statements the first time the allocator is invoked. |
| */ |
| function temporaryAllocator(statements, name) { |
| var temp = null; |
| return function () { |
| if (!temp) { |
| statements.push(new DeclareVarStmt(TEMPORARY_NAME, undefined, DYNAMIC_TYPE)); |
| temp = variable(name); |
| } |
| return temp; |
| }; |
| } |
| function unsupported(feature) { |
| if (this) { |
| throw new Error("Builder " + this.constructor.name + " doesn't support " + feature + " yet"); |
| } |
| throw new Error("Feature " + feature + " is not supported yet"); |
| } |
| function invalid$1(arg) { |
| throw new Error("Invalid state: Visitor " + this.constructor.name + " doesn't handle " + arg.constructor.name); |
| } |
| function asLiteral(value) { |
| if (Array.isArray(value)) { |
| return literalArr(value.map(asLiteral)); |
| } |
| return literal(value, INFERRED_TYPE); |
| } |
| function conditionallyCreateMapObjectLiteral(keys, keepDeclared) { |
| if (Object.getOwnPropertyNames(keys).length > 0) { |
| return mapToExpression(keys, keepDeclared); |
| } |
| return null; |
| } |
| function mapToExpression(map, keepDeclared) { |
| return literalMap(Object.getOwnPropertyNames(map).map(function (key) { |
| var _a, _b; |
| // canonical syntax: `dirProp: publicProp` |
| // if there is no `:`, use dirProp = elProp |
| var value = map[key]; |
| var declaredName; |
| var publicName; |
| var minifiedName; |
| if (Array.isArray(value)) { |
| _a = __read(value, 2), publicName = _a[0], declaredName = _a[1]; |
| } |
| else { |
| _b = __read(splitAtColon(key, [key, value]), 2), declaredName = _b[0], publicName = _b[1]; |
| } |
| minifiedName = declaredName; |
| return { |
| key: minifiedName, |
| // put quotes around keys that contain potentially unsafe characters |
| quoted: UNSAFE_OBJECT_KEY_NAME_REGEXP.test(minifiedName), |
| value: (keepDeclared && publicName !== declaredName) ? |
| literalArr([asLiteral(publicName), asLiteral(declaredName)]) : |
| asLiteral(publicName) |
| }; |
| })); |
| } |
| /** |
| * Remove trailing null nodes as they are implied. |
| */ |
| function trimTrailingNulls(parameters) { |
| while (isNull(parameters[parameters.length - 1])) { |
| parameters.pop(); |
| } |
| return parameters; |
| } |
| function getQueryPredicate(query, constantPool) { |
| if (Array.isArray(query.predicate)) { |
| var predicate_1 = []; |
| query.predicate.forEach(function (selector) { |
| // Each item in predicates array may contain strings with comma-separated refs |
| // (for ex. 'ref, ref1, ..., refN'), thus we extract individual refs and store them |
| // as separate array entities |
| var selectors = selector.split(',').map(function (token) { return literal(token.trim()); }); |
| predicate_1.push.apply(predicate_1, __spread(selectors)); |
| }); |
| return constantPool.getConstLiteral(literalArr(predicate_1), true); |
| } |
| else { |
| return query.predicate; |
| } |
| } |
| var DefinitionMap = /** @class */ (function () { |
| function DefinitionMap() { |
| this.values = []; |
| } |
| DefinitionMap.prototype.set = function (key, value) { |
| if (value) { |
| this.values.push({ key: key, value: value, quoted: false }); |
| } |
| }; |
| DefinitionMap.prototype.toLiteralMap = function () { return literalMap(this.values); }; |
| return DefinitionMap; |
| }()); |
| /** |
| * Extract a map of properties to values for a given element or template node, which can be used |
| * by the directive matching machinery. |
| * |
| * @param elOrTpl the element or template in question |
| * @return an object set up for directive matching. For attributes on the element/template, this |
| * object maps a property name to its (static) value. For any bindings, this map simply maps the |
| * property name to an empty string. |
| */ |
| function getAttrsForDirectiveMatching(elOrTpl) { |
| var attributesMap = {}; |
| if (elOrTpl instanceof Template && elOrTpl.tagName !== 'ng-template') { |
| elOrTpl.templateAttrs.forEach(function (a) { return attributesMap[a.name] = ''; }); |
| } |
| else { |
| elOrTpl.attributes.forEach(function (a) { |
| if (!isI18nAttribute(a.name)) { |
| attributesMap[a.name] = a.value; |
| } |
| }); |
| elOrTpl.inputs.forEach(function (i) { attributesMap[i.name] = ''; }); |
| elOrTpl.outputs.forEach(function (o) { attributesMap[o.name] = ''; }); |
| } |
| return attributesMap; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var R3FactoryDelegateType; |
| (function (R3FactoryDelegateType) { |
| R3FactoryDelegateType[R3FactoryDelegateType["Class"] = 0] = "Class"; |
| R3FactoryDelegateType[R3FactoryDelegateType["Function"] = 1] = "Function"; |
| R3FactoryDelegateType[R3FactoryDelegateType["Factory"] = 2] = "Factory"; |
| })(R3FactoryDelegateType || (R3FactoryDelegateType = {})); |
| (function (R3ResolvedDependencyType) { |
| /** |
| * A normal token dependency. |
| */ |
| R3ResolvedDependencyType[R3ResolvedDependencyType["Token"] = 0] = "Token"; |
| /** |
| * The dependency is for an attribute. |
| * |
| * The token expression is a string representing the attribute name. |
| */ |
| R3ResolvedDependencyType[R3ResolvedDependencyType["Attribute"] = 1] = "Attribute"; |
| })(exports.R3ResolvedDependencyType || (exports.R3ResolvedDependencyType = {})); |
| /** |
| * Construct a factory function expression for the given `R3FactoryMetadata`. |
| */ |
| function compileFactoryFunction(meta) { |
| var t = variable('t'); |
| var statements = []; |
| // The type to instantiate via constructor invocation. If there is no delegated factory, meaning |
| // this type is always created by constructor invocation, then this is the type-to-create |
| // parameter provided by the user (t) if specified, or the current type if not. If there is a |
| // delegated factory (which is used to create the current type) then this is only the type-to- |
| // create parameter (t). |
| var typeForCtor = !isDelegatedMetadata(meta) ? new BinaryOperatorExpr(exports.BinaryOperator.Or, t, meta.type) : t; |
| var ctorExpr = null; |
| if (meta.deps !== null) { |
| // There is a constructor (either explicitly or implicitly defined). |
| if (meta.deps !== 'invalid') { |
| ctorExpr = new InstantiateExpr(typeForCtor, injectDependencies(meta.deps, meta.injectFn)); |
| } |
| } |
| else { |
| var baseFactory = variable("\u0275" + meta.name + "_BaseFactory"); |
| var getInheritedFactory = importExpr(Identifiers$1.getInheritedFactory); |
| var baseFactoryStmt = baseFactory.set(getInheritedFactory.callFn([meta.type])).toDeclStmt(INFERRED_TYPE, [ |
| exports.StmtModifier.Exported, exports.StmtModifier.Final |
| ]); |
| statements.push(baseFactoryStmt); |
| // There is no constructor, use the base class' factory to construct typeForCtor. |
| ctorExpr = baseFactory.callFn([typeForCtor]); |
| } |
| var ctorExprFinal = ctorExpr; |
| var body = []; |
| var retExpr = null; |
| function makeConditionalFactory(nonCtorExpr) { |
| var r = variable('r'); |
| body.push(r.set(NULL_EXPR).toDeclStmt()); |
| var ctorStmt = null; |
| if (ctorExprFinal !== null) { |
| ctorStmt = r.set(ctorExprFinal).toStmt(); |
| } |
| else { |
| ctorStmt = makeErrorStmt(meta.name); |
| } |
| body.push(ifStmt(t, [ctorStmt], [r.set(nonCtorExpr).toStmt()])); |
| return r; |
| } |
| if (isDelegatedMetadata(meta) && meta.delegateType === R3FactoryDelegateType.Factory) { |
| var delegateFactory = variable("\u0275" + meta.name + "_BaseFactory"); |
| var getFactoryOf = importExpr(Identifiers$1.getFactoryOf); |
| if (meta.delegate.isEquivalent(meta.type)) { |
| throw new Error("Illegal state: compiling factory that delegates to itself"); |
| } |
| var delegateFactoryStmt = delegateFactory.set(getFactoryOf.callFn([meta.delegate])).toDeclStmt(INFERRED_TYPE, [ |
| exports.StmtModifier.Exported, exports.StmtModifier.Final |
| ]); |
| statements.push(delegateFactoryStmt); |
| retExpr = makeConditionalFactory(delegateFactory.callFn([])); |
| } |
| else if (isDelegatedMetadata(meta)) { |
| // This type is created with a delegated factory. If a type parameter is not specified, call |
| // the factory instead. |
| var delegateArgs = injectDependencies(meta.delegateDeps, meta.injectFn); |
| // Either call `new delegate(...)` or `delegate(...)` depending on meta.useNewForDelegate. |
| var factoryExpr = new (meta.delegateType === R3FactoryDelegateType.Class ? |
| InstantiateExpr : |
| InvokeFunctionExpr)(meta.delegate, delegateArgs); |
| retExpr = makeConditionalFactory(factoryExpr); |
| } |
| else if (isExpressionFactoryMetadata(meta)) { |
| // TODO(alxhub): decide whether to lower the value here or in the caller |
| retExpr = makeConditionalFactory(meta.expression); |
| } |
| else { |
| retExpr = ctorExpr; |
| } |
| if (retExpr !== null) { |
| body.push(new ReturnStatement(retExpr)); |
| } |
| else { |
| body.push(makeErrorStmt(meta.name)); |
| } |
| return { |
| factory: fn([new FnParam('t', DYNAMIC_TYPE)], body, INFERRED_TYPE, undefined, meta.name + "_Factory"), |
| statements: statements, |
| }; |
| } |
| function injectDependencies(deps, injectFn) { |
| return deps.map(function (dep) { return compileInjectDependency(dep, injectFn); }); |
| } |
| function compileInjectDependency(dep, injectFn) { |
| // Interpret the dependency according to its resolved type. |
| switch (dep.resolved) { |
| case exports.R3ResolvedDependencyType.Token: { |
| // Build up the injection flags according to the metadata. |
| var flags = 0 /* Default */ | (dep.self ? 2 /* Self */ : 0) | |
| (dep.skipSelf ? 4 /* SkipSelf */ : 0) | (dep.host ? 1 /* Host */ : 0) | |
| (dep.optional ? 8 /* Optional */ : 0); |
| // Build up the arguments to the injectFn call. |
| var injectArgs = [dep.token]; |
| // If this dependency is optional or otherwise has non-default flags, then additional |
| // parameters describing how to inject the dependency must be passed to the inject function |
| // that's being used. |
| if (flags !== 0 /* Default */ || dep.optional) { |
| injectArgs.push(literal(flags)); |
| } |
| return importExpr(injectFn).callFn(injectArgs); |
| } |
| case exports.R3ResolvedDependencyType.Attribute: |
| // In the case of attributes, the attribute name in question is given as the token. |
| return importExpr(Identifiers$1.injectAttribute).callFn([dep.token]); |
| default: |
| return unsupported("Unknown R3ResolvedDependencyType: " + exports.R3ResolvedDependencyType[dep.resolved]); |
| } |
| } |
| /** |
| * A helper function useful for extracting `R3DependencyMetadata` from a Render2 |
| * `CompileTypeMetadata` instance. |
| */ |
| function dependenciesFromGlobalMetadata(type, outputCtx, reflector) { |
| var e_1, _a; |
| // Use the `CompileReflector` to look up references to some well-known Angular types. These will |
| // be compared with the token to statically determine whether the token has significance to |
| // Angular, and set the correct `R3ResolvedDependencyType` as a result. |
| var injectorRef = reflector.resolveExternalReference(Identifiers.Injector); |
| // Iterate through the type's DI dependencies and produce `R3DependencyMetadata` for each of them. |
| var deps = []; |
| try { |
| for (var _b = __values(type.diDeps), _c = _b.next(); !_c.done; _c = _b.next()) { |
| var dependency = _c.value; |
| if (dependency.token) { |
| var tokenRef = tokenReference(dependency.token); |
| var resolved = dependency.isAttribute ? |
| exports.R3ResolvedDependencyType.Attribute : |
| exports.R3ResolvedDependencyType.Token; |
| // In the case of most dependencies, the token will be a reference to a type. Sometimes, |
| // however, it can be a string, in the case of older Angular code or @Attribute injection. |
| var token = tokenRef instanceof StaticSymbol ? outputCtx.importExpr(tokenRef) : literal(tokenRef); |
| // Construct the dependency. |
| deps.push({ |
| token: token, |
| resolved: resolved, |
| host: !!dependency.isHost, |
| optional: !!dependency.isOptional, |
| self: !!dependency.isSelf, |
| skipSelf: !!dependency.isSkipSelf, |
| }); |
| } |
| else { |
| unsupported('dependency without a token'); |
| } |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (_c && !_c.done && (_a = _b.return)) _a.call(_b); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| return deps; |
| } |
| function makeErrorStmt(name) { |
| return new ThrowStmt(new InstantiateExpr(new ReadVarExpr('Error'), [ |
| literal(name + " has a constructor which is not compatible with Dependency Injection. It should probably not be @Injectable().") |
| ])); |
| } |
| function isDelegatedMetadata(meta) { |
| return meta.delegateType !== undefined; |
| } |
| function isExpressionFactoryMetadata(meta) { |
| return meta.expression !== undefined; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * Convert an object map with `Expression` values into a `LiteralMapExpr`. |
| */ |
| function mapToMapExpression(map) { |
| var result = Object.keys(map).map(function (key) { return ({ key: key, value: map[key], quoted: false }); }); |
| return literalMap(result); |
| } |
| /** |
| * Convert metadata into an `Expression` in the given `OutputContext`. |
| * |
| * This operation will handle arrays, references to symbols, or literal `null` or `undefined`. |
| */ |
| function convertMetaToOutput(meta, ctx) { |
| if (Array.isArray(meta)) { |
| return literalArr(meta.map(function (entry) { return convertMetaToOutput(entry, ctx); })); |
| } |
| if (meta instanceof StaticSymbol) { |
| return ctx.importExpr(meta); |
| } |
| if (meta == null) { |
| return literal(meta); |
| } |
| throw new Error("Internal error: Unsupported or unknown metadata: " + meta); |
| } |
| function typeWithParameters(type, numParams) { |
| var params = null; |
| if (numParams > 0) { |
| params = []; |
| for (var i = 0; i < numParams; i++) { |
| params.push(DYNAMIC_TYPE); |
| } |
| } |
| return expressionType(type, null, params); |
| } |
| var ANIMATE_SYMBOL_PREFIX = '@'; |
| function prepareSyntheticPropertyName(name) { |
| return "" + ANIMATE_SYMBOL_PREFIX + name; |
| } |
| function prepareSyntheticListenerName(name, phase) { |
| return "" + ANIMATE_SYMBOL_PREFIX + name + "." + phase; |
| } |
| function prepareSyntheticListenerFunctionName(name, phase) { |
| return "animation_" + name + "_" + phase; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| function compileInjectable(meta) { |
| var result = null; |
| var factoryMeta = { |
| name: meta.name, |
| type: meta.type, |
| deps: meta.ctorDeps, |
| injectFn: Identifiers.inject, |
| }; |
| if (meta.useClass !== undefined) { |
| // meta.useClass has two modes of operation. Either deps are specified, in which case `new` is |
| // used to instantiate the class with dependencies injected, or deps are not specified and |
| // the factory of the class is used to instantiate it. |
| // |
| // A special case exists for useClass: Type where Type is the injectable type itself and no |
| // deps are specified, in which case 'useClass' is effectively ignored. |
| var useClassOnSelf = meta.useClass.isEquivalent(meta.type); |
| var deps = undefined; |
| if (meta.userDeps !== undefined) { |
| deps = meta.userDeps; |
| } |
| if (deps !== undefined) { |
| // factory: () => new meta.useClass(...deps) |
| result = compileFactoryFunction(__assign({}, factoryMeta, { delegate: meta.useClass, delegateDeps: deps, delegateType: R3FactoryDelegateType.Class })); |
| } |
| else if (useClassOnSelf) { |
| result = compileFactoryFunction(factoryMeta); |
| } |
| else { |
| result = compileFactoryFunction(__assign({}, factoryMeta, { delegate: meta.useClass, delegateType: R3FactoryDelegateType.Factory })); |
| } |
| } |
| else if (meta.useFactory !== undefined) { |
| result = compileFactoryFunction(__assign({}, factoryMeta, { delegate: meta.useFactory, delegateDeps: meta.userDeps || [], delegateType: R3FactoryDelegateType.Function })); |
| } |
| else if (meta.useValue !== undefined) { |
| // Note: it's safe to use `meta.useValue` instead of the `USE_VALUE in meta` check used for |
| // client code because meta.useValue is an Expression which will be defined even if the actual |
| // value is undefined. |
| result = compileFactoryFunction(__assign({}, factoryMeta, { expression: meta.useValue })); |
| } |
| else if (meta.useExisting !== undefined) { |
| // useExisting is an `inject` call on the existing token. |
| result = compileFactoryFunction(__assign({}, factoryMeta, { expression: importExpr(Identifiers.inject).callFn([meta.useExisting]) })); |
| } |
| else { |
| result = compileFactoryFunction(factoryMeta); |
| } |
| var token = meta.type; |
| var providedIn = meta.providedIn; |
| var expression = importExpr(Identifiers.ɵɵdefineInjectable).callFn([mapToMapExpression({ token: token, factory: result.factory, providedIn: providedIn })]); |
| var type = new ExpressionType(importExpr(Identifiers.InjectableDef, [typeWithParameters(meta.type, meta.typeArgumentCount)])); |
| return { |
| expression: expression, |
| type: type, |
| statements: result.statements, |
| }; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| function assertArrayOfStrings(identifier, value) { |
| if (value == null) { |
| return; |
| } |
| if (!Array.isArray(value)) { |
| throw new Error("Expected '" + identifier + "' to be an array of strings."); |
| } |
| for (var i = 0; i < value.length; i += 1) { |
| if (typeof value[i] !== 'string') { |
| throw new Error("Expected '" + identifier + "' to be an array of strings."); |
| } |
| } |
| } |
| var UNUSABLE_INTERPOLATION_REGEXPS = [ |
| /^\s*$/, |
| /[<>]/, |
| /^[{}]$/, |
| /&(#|[a-z])/i, |
| /^\/\//, |
| ]; |
| function assertInterpolationSymbols(identifier, value) { |
| if (value != null && !(Array.isArray(value) && value.length == 2)) { |
| throw new Error("Expected '" + identifier + "' to be an array, [start, end]."); |
| } |
| else if (value != null) { |
| var start_1 = value[0]; |
| var end_1 = value[1]; |
| // Check for unusable interpolation symbols |
| UNUSABLE_INTERPOLATION_REGEXPS.forEach(function (regexp) { |
| if (regexp.test(start_1) || regexp.test(end_1)) { |
| throw new Error("['" + start_1 + "', '" + end_1 + "'] contains unusable interpolation symbol."); |
| } |
| }); |
| } |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var InterpolationConfig = /** @class */ (function () { |
| function InterpolationConfig(start, end) { |
| this.start = start; |
| this.end = end; |
| } |
| InterpolationConfig.fromArray = function (markers) { |
| if (!markers) { |
| return DEFAULT_INTERPOLATION_CONFIG; |
| } |
| assertInterpolationSymbols('interpolation', markers); |
| return new InterpolationConfig(markers[0], markers[1]); |
| }; |
| return InterpolationConfig; |
| }()); |
| var DEFAULT_INTERPOLATION_CONFIG = new InterpolationConfig('{{', '}}'); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| // https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit |
| var VERSION = 3; |
| var JS_B64_PREFIX = '# sourceMappingURL=data:application/json;base64,'; |
| var SourceMapGenerator = /** @class */ (function () { |
| function SourceMapGenerator(file) { |
| if (file === void 0) { file = null; } |
| this.file = file; |
| this.sourcesContent = new Map(); |
| this.lines = []; |
| this.lastCol0 = 0; |
| this.hasMappings = false; |
| } |
| // The content is `null` when the content is expected to be loaded using the URL |
| SourceMapGenerator.prototype.addSource = function (url, content) { |
| if (content === void 0) { content = null; } |
| if (!this.sourcesContent.has(url)) { |
| this.sourcesContent.set(url, content); |
| } |
| return this; |
| }; |
| SourceMapGenerator.prototype.addLine = function () { |
| this.lines.push([]); |
| this.lastCol0 = 0; |
| return this; |
| }; |
| SourceMapGenerator.prototype.addMapping = function (col0, sourceUrl, sourceLine0, sourceCol0) { |
| if (!this.currentLine) { |
| throw new Error("A line must be added before mappings can be added"); |
| } |
| if (sourceUrl != null && !this.sourcesContent.has(sourceUrl)) { |
| throw new Error("Unknown source file \"" + sourceUrl + "\""); |
| } |
| if (col0 == null) { |
| throw new Error("The column in the generated code must be provided"); |
| } |
| if (col0 < this.lastCol0) { |
| throw new Error("Mapping should be added in output order"); |
| } |
| if (sourceUrl && (sourceLine0 == null || sourceCol0 == null)) { |
| throw new Error("The source location must be provided when a source url is provided"); |
| } |
| this.hasMappings = true; |
| this.lastCol0 = col0; |
| this.currentLine.push({ col0: col0, sourceUrl: sourceUrl, sourceLine0: sourceLine0, sourceCol0: sourceCol0 }); |
| return this; |
| }; |
| Object.defineProperty(SourceMapGenerator.prototype, "currentLine", { |
| get: function () { return this.lines.slice(-1)[0]; }, |
| enumerable: true, |
| configurable: true |
| }); |
| SourceMapGenerator.prototype.toJSON = function () { |
| var _this = this; |
| if (!this.hasMappings) { |
| return null; |
| } |
| var sourcesIndex = new Map(); |
| var sources = []; |
| var sourcesContent = []; |
| Array.from(this.sourcesContent.keys()).forEach(function (url, i) { |
| sourcesIndex.set(url, i); |
| sources.push(url); |
| sourcesContent.push(_this.sourcesContent.get(url) || null); |
| }); |
| var mappings = ''; |
| var lastCol0 = 0; |
| var lastSourceIndex = 0; |
| var lastSourceLine0 = 0; |
| var lastSourceCol0 = 0; |
| this.lines.forEach(function (segments) { |
| lastCol0 = 0; |
| mappings += segments |
| .map(function (segment) { |
| // zero-based starting column of the line in the generated code |
| var segAsStr = toBase64VLQ(segment.col0 - lastCol0); |
| lastCol0 = segment.col0; |
| if (segment.sourceUrl != null) { |
| // zero-based index into the “sources” list |
| segAsStr += |
| toBase64VLQ(sourcesIndex.get(segment.sourceUrl) - lastSourceIndex); |
| lastSourceIndex = sourcesIndex.get(segment.sourceUrl); |
| // the zero-based starting line in the original source |
| segAsStr += toBase64VLQ(segment.sourceLine0 - lastSourceLine0); |
| lastSourceLine0 = segment.sourceLine0; |
| // the zero-based starting column in the original source |
| segAsStr += toBase64VLQ(segment.sourceCol0 - lastSourceCol0); |
| lastSourceCol0 = segment.sourceCol0; |
| } |
| return segAsStr; |
| }) |
| .join(','); |
| mappings += ';'; |
| }); |
| mappings = mappings.slice(0, -1); |
| return { |
| 'file': this.file || '', |
| 'version': VERSION, |
| 'sourceRoot': '', |
| 'sources': sources, |
| 'sourcesContent': sourcesContent, |
| 'mappings': mappings, |
| }; |
| }; |
| SourceMapGenerator.prototype.toJsComment = function () { |
| return this.hasMappings ? '//' + JS_B64_PREFIX + toBase64String(JSON.stringify(this, null, 0)) : |
| ''; |
| }; |
| return SourceMapGenerator; |
| }()); |
| function toBase64String(value) { |
| var b64 = ''; |
| value = utf8Encode(value); |
| for (var i = 0; i < value.length;) { |
| var i1 = value.charCodeAt(i++); |
| var i2 = value.charCodeAt(i++); |
| var i3 = value.charCodeAt(i++); |
| b64 += toBase64Digit(i1 >> 2); |
| b64 += toBase64Digit(((i1 & 3) << 4) | (isNaN(i2) ? 0 : i2 >> 4)); |
| b64 += isNaN(i2) ? '=' : toBase64Digit(((i2 & 15) << 2) | (i3 >> 6)); |
| b64 += isNaN(i2) || isNaN(i3) ? '=' : toBase64Digit(i3 & 63); |
| } |
| return b64; |
| } |
| function toBase64VLQ(value) { |
| value = value < 0 ? ((-value) << 1) + 1 : value << 1; |
| var out = ''; |
| do { |
| var digit = value & 31; |
| value = value >> 5; |
| if (value > 0) { |
| digit = digit | 32; |
| } |
| out += toBase64Digit(digit); |
| } while (value > 0); |
| return out; |
| } |
| var B64_DIGITS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; |
| function toBase64Digit(value) { |
| if (value < 0 || value >= 64) { |
| throw new Error("Can only encode value in the range [0, 63]"); |
| } |
| return B64_DIGITS[value]; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var _SINGLE_QUOTE_ESCAPE_STRING_RE = /'|\\|\n|\r|\$/g; |
| var _LEGAL_IDENTIFIER_RE = /^[$A-Z_][0-9A-Z_$]*$/i; |
| var _INDENT_WITH = ' '; |
| var CATCH_ERROR_VAR$1 = variable('error', null, null); |
| var CATCH_STACK_VAR$1 = variable('stack', null, null); |
| var _EmittedLine = /** @class */ (function () { |
| function _EmittedLine(indent) { |
| this.indent = indent; |
| this.partsLength = 0; |
| this.parts = []; |
| this.srcSpans = []; |
| } |
| return _EmittedLine; |
| }()); |
| var EmitterVisitorContext = /** @class */ (function () { |
| function EmitterVisitorContext(_indent) { |
| this._indent = _indent; |
| this._classes = []; |
| this._preambleLineCount = 0; |
| this._lines = [new _EmittedLine(_indent)]; |
| } |
| EmitterVisitorContext.createRoot = function () { return new EmitterVisitorContext(0); }; |
| Object.defineProperty(EmitterVisitorContext.prototype, "_currentLine", { |
| get: function () { return this._lines[this._lines.length - 1]; }, |
| enumerable: true, |
| configurable: true |
| }); |
| EmitterVisitorContext.prototype.println = function (from, lastPart) { |
| if (lastPart === void 0) { lastPart = ''; } |
| this.print(from || null, lastPart, true); |
| }; |
| EmitterVisitorContext.prototype.lineIsEmpty = function () { return this._currentLine.parts.length === 0; }; |
| EmitterVisitorContext.prototype.lineLength = function () { |
| return this._currentLine.indent * _INDENT_WITH.length + this._currentLine.partsLength; |
| }; |
| EmitterVisitorContext.prototype.print = function (from, part, newLine) { |
| if (newLine === void 0) { newLine = false; } |
| if (part.length > 0) { |
| this._currentLine.parts.push(part); |
| this._currentLine.partsLength += part.length; |
| this._currentLine.srcSpans.push(from && from.sourceSpan || null); |
| } |
| if (newLine) { |
| this._lines.push(new _EmittedLine(this._indent)); |
| } |
| }; |
| EmitterVisitorContext.prototype.removeEmptyLastLine = function () { |
| if (this.lineIsEmpty()) { |
| this._lines.pop(); |
| } |
| }; |
| EmitterVisitorContext.prototype.incIndent = function () { |
| this._indent++; |
| if (this.lineIsEmpty()) { |
| this._currentLine.indent = this._indent; |
| } |
| }; |
| EmitterVisitorContext.prototype.decIndent = function () { |
| this._indent--; |
| if (this.lineIsEmpty()) { |
| this._currentLine.indent = this._indent; |
| } |
| }; |
| EmitterVisitorContext.prototype.pushClass = function (clazz) { this._classes.push(clazz); }; |
| EmitterVisitorContext.prototype.popClass = function () { return this._classes.pop(); }; |
| Object.defineProperty(EmitterVisitorContext.prototype, "currentClass", { |
| get: function () { |
| return this._classes.length > 0 ? this._classes[this._classes.length - 1] : null; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| EmitterVisitorContext.prototype.toSource = function () { |
| return this.sourceLines |
| .map(function (l) { return l.parts.length > 0 ? _createIndent(l.indent) + l.parts.join('') : ''; }) |
| .join('\n'); |
| }; |
| EmitterVisitorContext.prototype.toSourceMapGenerator = function (genFilePath, startsAtLine) { |
| if (startsAtLine === void 0) { startsAtLine = 0; } |
| var map = new SourceMapGenerator(genFilePath); |
| var firstOffsetMapped = false; |
| var mapFirstOffsetIfNeeded = function () { |
| if (!firstOffsetMapped) { |
| // Add a single space so that tools won't try to load the file from disk. |
| // Note: We are using virtual urls like `ng:///`, so we have to |
| // provide a content here. |
| map.addSource(genFilePath, ' ').addMapping(0, genFilePath, 0, 0); |
| firstOffsetMapped = true; |
| } |
| }; |
| for (var i = 0; i < startsAtLine; i++) { |
| map.addLine(); |
| mapFirstOffsetIfNeeded(); |
| } |
| this.sourceLines.forEach(function (line, lineIdx) { |
| map.addLine(); |
| var spans = line.srcSpans; |
| var parts = line.parts; |
| var col0 = line.indent * _INDENT_WITH.length; |
| var spanIdx = 0; |
| // skip leading parts without source spans |
| while (spanIdx < spans.length && !spans[spanIdx]) { |
| col0 += parts[spanIdx].length; |
| spanIdx++; |
| } |
| if (spanIdx < spans.length && lineIdx === 0 && col0 === 0) { |
| firstOffsetMapped = true; |
| } |
| else { |
| mapFirstOffsetIfNeeded(); |
| } |
| while (spanIdx < spans.length) { |
| var span = spans[spanIdx]; |
| var source = span.start.file; |
| var sourceLine = span.start.line; |
| var sourceCol = span.start.col; |
| map.addSource(source.url, source.content) |
| .addMapping(col0, source.url, sourceLine, sourceCol); |
| col0 += parts[spanIdx].length; |
| spanIdx++; |
| // assign parts without span or the same span to the previous segment |
| while (spanIdx < spans.length && (span === spans[spanIdx] || !spans[spanIdx])) { |
| col0 += parts[spanIdx].length; |
| spanIdx++; |
| } |
| } |
| }); |
| return map; |
| }; |
| EmitterVisitorContext.prototype.setPreambleLineCount = function (count) { return this._preambleLineCount = count; }; |
| EmitterVisitorContext.prototype.spanOf = function (line, column) { |
| var emittedLine = this._lines[line - this._preambleLineCount]; |
| if (emittedLine) { |
| var columnsLeft = column - _createIndent(emittedLine.indent).length; |
| for (var partIndex = 0; partIndex < emittedLine.parts.length; partIndex++) { |
| var part = emittedLine.parts[partIndex]; |
| if (part.length > columnsLeft) { |
| return emittedLine.srcSpans[partIndex]; |
| } |
| columnsLeft -= part.length; |
| } |
| } |
| return null; |
| }; |
| Object.defineProperty(EmitterVisitorContext.prototype, "sourceLines", { |
| get: function () { |
| if (this._lines.length && this._lines[this._lines.length - 1].parts.length === 0) { |
| return this._lines.slice(0, -1); |
| } |
| return this._lines; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| return EmitterVisitorContext; |
| }()); |
| var AbstractEmitterVisitor = /** @class */ (function () { |
| function AbstractEmitterVisitor(_escapeDollarInStrings) { |
| this._escapeDollarInStrings = _escapeDollarInStrings; |
| } |
| AbstractEmitterVisitor.prototype.visitExpressionStmt = function (stmt, ctx) { |
| stmt.expr.visitExpression(this, ctx); |
| ctx.println(stmt, ';'); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitReturnStmt = function (stmt, ctx) { |
| ctx.print(stmt, "return "); |
| stmt.value.visitExpression(this, ctx); |
| ctx.println(stmt, ';'); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitIfStmt = function (stmt, ctx) { |
| ctx.print(stmt, "if ("); |
| stmt.condition.visitExpression(this, ctx); |
| ctx.print(stmt, ") {"); |
| var hasElseCase = stmt.falseCase != null && stmt.falseCase.length > 0; |
| if (stmt.trueCase.length <= 1 && !hasElseCase) { |
| ctx.print(stmt, " "); |
| this.visitAllStatements(stmt.trueCase, ctx); |
| ctx.removeEmptyLastLine(); |
| ctx.print(stmt, " "); |
| } |
| else { |
| ctx.println(); |
| ctx.incIndent(); |
| this.visitAllStatements(stmt.trueCase, ctx); |
| ctx.decIndent(); |
| if (hasElseCase) { |
| ctx.println(stmt, "} else {"); |
| ctx.incIndent(); |
| this.visitAllStatements(stmt.falseCase, ctx); |
| ctx.decIndent(); |
| } |
| } |
| ctx.println(stmt, "}"); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitThrowStmt = function (stmt, ctx) { |
| ctx.print(stmt, "throw "); |
| stmt.error.visitExpression(this, ctx); |
| ctx.println(stmt, ";"); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitCommentStmt = function (stmt, ctx) { |
| if (stmt.multiline) { |
| ctx.println(stmt, "/* " + stmt.comment + " */"); |
| } |
| else { |
| stmt.comment.split('\n').forEach(function (line) { ctx.println(stmt, "// " + line); }); |
| } |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitJSDocCommentStmt = function (stmt, ctx) { |
| ctx.println(stmt, "/*" + stmt.toString() + "*/"); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitWriteVarExpr = function (expr, ctx) { |
| var lineWasEmpty = ctx.lineIsEmpty(); |
| if (!lineWasEmpty) { |
| ctx.print(expr, '('); |
| } |
| ctx.print(expr, expr.name + " = "); |
| expr.value.visitExpression(this, ctx); |
| if (!lineWasEmpty) { |
| ctx.print(expr, ')'); |
| } |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitWriteKeyExpr = function (expr, ctx) { |
| var lineWasEmpty = ctx.lineIsEmpty(); |
| if (!lineWasEmpty) { |
| ctx.print(expr, '('); |
| } |
| expr.receiver.visitExpression(this, ctx); |
| ctx.print(expr, "["); |
| expr.index.visitExpression(this, ctx); |
| ctx.print(expr, "] = "); |
| expr.value.visitExpression(this, ctx); |
| if (!lineWasEmpty) { |
| ctx.print(expr, ')'); |
| } |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitWritePropExpr = function (expr, ctx) { |
| var lineWasEmpty = ctx.lineIsEmpty(); |
| if (!lineWasEmpty) { |
| ctx.print(expr, '('); |
| } |
| expr.receiver.visitExpression(this, ctx); |
| ctx.print(expr, "." + expr.name + " = "); |
| expr.value.visitExpression(this, ctx); |
| if (!lineWasEmpty) { |
| ctx.print(expr, ')'); |
| } |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitInvokeMethodExpr = function (expr, ctx) { |
| expr.receiver.visitExpression(this, ctx); |
| var name = expr.name; |
| if (expr.builtin != null) { |
| name = this.getBuiltinMethodName(expr.builtin); |
| if (name == null) { |
| // some builtins just mean to skip the call. |
| return null; |
| } |
| } |
| ctx.print(expr, "." + name + "("); |
| this.visitAllExpressions(expr.args, ctx, ","); |
| ctx.print(expr, ")"); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitInvokeFunctionExpr = function (expr, ctx) { |
| expr.fn.visitExpression(this, ctx); |
| ctx.print(expr, "("); |
| this.visitAllExpressions(expr.args, ctx, ','); |
| ctx.print(expr, ")"); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitWrappedNodeExpr = function (ast, ctx) { |
| throw new Error('Abstract emitter cannot visit WrappedNodeExpr.'); |
| }; |
| AbstractEmitterVisitor.prototype.visitTypeofExpr = function (expr, ctx) { |
| ctx.print(expr, 'typeof '); |
| expr.expr.visitExpression(this, ctx); |
| }; |
| AbstractEmitterVisitor.prototype.visitReadVarExpr = function (ast, ctx) { |
| var varName = ast.name; |
| if (ast.builtin != null) { |
| switch (ast.builtin) { |
| case exports.BuiltinVar.Super: |
| varName = 'super'; |
| break; |
| case exports.BuiltinVar.This: |
| varName = 'this'; |
| break; |
| case exports.BuiltinVar.CatchError: |
| varName = CATCH_ERROR_VAR$1.name; |
| break; |
| case exports.BuiltinVar.CatchStack: |
| varName = CATCH_STACK_VAR$1.name; |
| break; |
| default: |
| throw new Error("Unknown builtin variable " + ast.builtin); |
| } |
| } |
| ctx.print(ast, varName); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitInstantiateExpr = function (ast, ctx) { |
| ctx.print(ast, "new "); |
| ast.classExpr.visitExpression(this, ctx); |
| ctx.print(ast, "("); |
| this.visitAllExpressions(ast.args, ctx, ','); |
| ctx.print(ast, ")"); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitLiteralExpr = function (ast, ctx) { |
| var value = ast.value; |
| if (typeof value === 'string') { |
| ctx.print(ast, escapeIdentifier(value, this._escapeDollarInStrings)); |
| } |
| else { |
| ctx.print(ast, "" + value); |
| } |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitConditionalExpr = function (ast, ctx) { |
| ctx.print(ast, "("); |
| ast.condition.visitExpression(this, ctx); |
| ctx.print(ast, '? '); |
| ast.trueCase.visitExpression(this, ctx); |
| ctx.print(ast, ': '); |
| ast.falseCase.visitExpression(this, ctx); |
| ctx.print(ast, ")"); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitNotExpr = function (ast, ctx) { |
| ctx.print(ast, '!'); |
| ast.condition.visitExpression(this, ctx); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitAssertNotNullExpr = function (ast, ctx) { |
| ast.condition.visitExpression(this, ctx); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitBinaryOperatorExpr = function (ast, ctx) { |
| var opStr; |
| switch (ast.operator) { |
| case exports.BinaryOperator.Equals: |
| opStr = '=='; |
| break; |
| case exports.BinaryOperator.Identical: |
| opStr = '==='; |
| break; |
| case exports.BinaryOperator.NotEquals: |
| opStr = '!='; |
| break; |
| case exports.BinaryOperator.NotIdentical: |
| opStr = '!=='; |
| break; |
| case exports.BinaryOperator.And: |
| opStr = '&&'; |
| break; |
| case exports.BinaryOperator.BitwiseAnd: |
| opStr = '&'; |
| break; |
| case exports.BinaryOperator.Or: |
| opStr = '||'; |
| break; |
| case exports.BinaryOperator.Plus: |
| opStr = '+'; |
| break; |
| case exports.BinaryOperator.Minus: |
| opStr = '-'; |
| break; |
| case exports.BinaryOperator.Divide: |
| opStr = '/'; |
| break; |
| case exports.BinaryOperator.Multiply: |
| opStr = '*'; |
| break; |
| case exports.BinaryOperator.Modulo: |
| opStr = '%'; |
| break; |
| case exports.BinaryOperator.Lower: |
| opStr = '<'; |
| break; |
| case exports.BinaryOperator.LowerEquals: |
| opStr = '<='; |
| break; |
| case exports.BinaryOperator.Bigger: |
| opStr = '>'; |
| break; |
| case exports.BinaryOperator.BiggerEquals: |
| opStr = '>='; |
| break; |
| default: |
| throw new Error("Unknown operator " + ast.operator); |
| } |
| if (ast.parens) |
| ctx.print(ast, "("); |
| ast.lhs.visitExpression(this, ctx); |
| ctx.print(ast, " " + opStr + " "); |
| ast.rhs.visitExpression(this, ctx); |
| if (ast.parens) |
| ctx.print(ast, ")"); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitReadPropExpr = function (ast, ctx) { |
| ast.receiver.visitExpression(this, ctx); |
| ctx.print(ast, "."); |
| ctx.print(ast, ast.name); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitReadKeyExpr = function (ast, ctx) { |
| ast.receiver.visitExpression(this, ctx); |
| ctx.print(ast, "["); |
| ast.index.visitExpression(this, ctx); |
| ctx.print(ast, "]"); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitLiteralArrayExpr = function (ast, ctx) { |
| ctx.print(ast, "["); |
| this.visitAllExpressions(ast.entries, ctx, ','); |
| ctx.print(ast, "]"); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitLiteralMapExpr = function (ast, ctx) { |
| var _this = this; |
| ctx.print(ast, "{"); |
| this.visitAllObjects(function (entry) { |
| ctx.print(ast, escapeIdentifier(entry.key, _this._escapeDollarInStrings, entry.quoted) + ":"); |
| entry.value.visitExpression(_this, ctx); |
| }, ast.entries, ctx, ','); |
| ctx.print(ast, "}"); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitCommaExpr = function (ast, ctx) { |
| ctx.print(ast, '('); |
| this.visitAllExpressions(ast.parts, ctx, ','); |
| ctx.print(ast, ')'); |
| return null; |
| }; |
| AbstractEmitterVisitor.prototype.visitAllExpressions = function (expressions, ctx, separator) { |
| var _this = this; |
| this.visitAllObjects(function (expr) { return expr.visitExpression(_this, ctx); }, expressions, ctx, separator); |
| }; |
| AbstractEmitterVisitor.prototype.visitAllObjects = function (handler, expressions, ctx, separator) { |
| var incrementedIndent = false; |
| for (var i = 0; i < expressions.length; i++) { |
| if (i > 0) { |
| if (ctx.lineLength() > 80) { |
| ctx.print(null, separator, true); |
| if (!incrementedIndent) { |
| // continuation are marked with double indent. |
| ctx.incIndent(); |
| ctx.incIndent(); |
| incrementedIndent = true; |
| } |
| } |
| else { |
| ctx.print(null, separator, false); |
| } |
| } |
| handler(expressions[i]); |
| } |
| if (incrementedIndent) { |
| // continuation are marked with double indent. |
| ctx.decIndent(); |
| ctx.decIndent(); |
| } |
| }; |
| AbstractEmitterVisitor.prototype.visitAllStatements = function (statements, ctx) { |
| var _this = this; |
| statements.forEach(function (stmt) { return stmt.visitStatement(_this, ctx); }); |
| }; |
| return AbstractEmitterVisitor; |
| }()); |
| function escapeIdentifier(input, escapeDollar, alwaysQuote) { |
| if (alwaysQuote === void 0) { alwaysQuote = true; } |
| if (input == null) { |
| return null; |
| } |
| var body = input.replace(_SINGLE_QUOTE_ESCAPE_STRING_RE, function () { |
| var match = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| match[_i] = arguments[_i]; |
| } |
| if (match[0] == '$') { |
| return escapeDollar ? '\\$' : '$'; |
| } |
| else if (match[0] == '\n') { |
| return '\\n'; |
| } |
| else if (match[0] == '\r') { |
| return '\\r'; |
| } |
| else { |
| return "\\" + match[0]; |
| } |
| }); |
| var requiresQuotes = alwaysQuote || !_LEGAL_IDENTIFIER_RE.test(body); |
| return requiresQuotes ? "'" + body + "'" : body; |
| } |
| function _createIndent(count) { |
| var res = ''; |
| for (var i = 0; i < count; i++) { |
| res += _INDENT_WITH; |
| } |
| return res; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var AbstractJsEmitterVisitor = /** @class */ (function (_super) { |
| __extends(AbstractJsEmitterVisitor, _super); |
| function AbstractJsEmitterVisitor() { |
| return _super.call(this, false) || this; |
| } |
| AbstractJsEmitterVisitor.prototype.visitDeclareClassStmt = function (stmt, ctx) { |
| var _this = this; |
| ctx.pushClass(stmt); |
| this._visitClassConstructor(stmt, ctx); |
| if (stmt.parent != null) { |
| ctx.print(stmt, stmt.name + ".prototype = Object.create("); |
| stmt.parent.visitExpression(this, ctx); |
| ctx.println(stmt, ".prototype);"); |
| } |
| stmt.getters.forEach(function (getter) { return _this._visitClassGetter(stmt, getter, ctx); }); |
| stmt.methods.forEach(function (method) { return _this._visitClassMethod(stmt, method, ctx); }); |
| ctx.popClass(); |
| return null; |
| }; |
| AbstractJsEmitterVisitor.prototype._visitClassConstructor = function (stmt, ctx) { |
| ctx.print(stmt, "function " + stmt.name + "("); |
| if (stmt.constructorMethod != null) { |
| this._visitParams(stmt.constructorMethod.params, ctx); |
| } |
| ctx.println(stmt, ") {"); |
| ctx.incIndent(); |
| if (stmt.constructorMethod != null) { |
| if (stmt.constructorMethod.body.length > 0) { |
| ctx.println(stmt, "var self = this;"); |
| this.visitAllStatements(stmt.constructorMethod.body, ctx); |
| } |
| } |
| ctx.decIndent(); |
| ctx.println(stmt, "}"); |
| }; |
| AbstractJsEmitterVisitor.prototype._visitClassGetter = function (stmt, getter, ctx) { |
| ctx.println(stmt, "Object.defineProperty(" + stmt.name + ".prototype, '" + getter.name + "', { get: function() {"); |
| ctx.incIndent(); |
| if (getter.body.length > 0) { |
| ctx.println(stmt, "var self = this;"); |
| this.visitAllStatements(getter.body, ctx); |
| } |
| ctx.decIndent(); |
| ctx.println(stmt, "}});"); |
| }; |
| AbstractJsEmitterVisitor.prototype._visitClassMethod = function (stmt, method, ctx) { |
| ctx.print(stmt, stmt.name + ".prototype." + method.name + " = function("); |
| this._visitParams(method.params, ctx); |
| ctx.println(stmt, ") {"); |
| ctx.incIndent(); |
| if (method.body.length > 0) { |
| ctx.println(stmt, "var self = this;"); |
| this.visitAllStatements(method.body, ctx); |
| } |
| ctx.decIndent(); |
| ctx.println(stmt, "};"); |
| }; |
| AbstractJsEmitterVisitor.prototype.visitWrappedNodeExpr = function (ast, ctx) { |
| throw new Error('Cannot emit a WrappedNodeExpr in Javascript.'); |
| }; |
| AbstractJsEmitterVisitor.prototype.visitReadVarExpr = function (ast, ctx) { |
| if (ast.builtin === exports.BuiltinVar.This) { |
| ctx.print(ast, 'self'); |
| } |
| else if (ast.builtin === exports.BuiltinVar.Super) { |
| throw new Error("'super' needs to be handled at a parent ast node, not at the variable level!"); |
| } |
| else { |
| _super.prototype.visitReadVarExpr.call(this, ast, ctx); |
| } |
| return null; |
| }; |
| AbstractJsEmitterVisitor.prototype.visitDeclareVarStmt = function (stmt, ctx) { |
| ctx.print(stmt, "var " + stmt.name); |
| if (stmt.value) { |
| ctx.print(stmt, ' = '); |
| stmt.value.visitExpression(this, ctx); |
| } |
| ctx.println(stmt, ";"); |
| return null; |
| }; |
| AbstractJsEmitterVisitor.prototype.visitCastExpr = function (ast, ctx) { |
| ast.value.visitExpression(this, ctx); |
| return null; |
| }; |
| AbstractJsEmitterVisitor.prototype.visitInvokeFunctionExpr = function (expr, ctx) { |
| var fnExpr = expr.fn; |
| if (fnExpr instanceof ReadVarExpr && fnExpr.builtin === exports.BuiltinVar.Super) { |
| ctx.currentClass.parent.visitExpression(this, ctx); |
| ctx.print(expr, ".call(this"); |
| if (expr.args.length > 0) { |
| ctx.print(expr, ", "); |
| this.visitAllExpressions(expr.args, ctx, ','); |
| } |
| ctx.print(expr, ")"); |
| } |
| else { |
| _super.prototype.visitInvokeFunctionExpr.call(this, expr, ctx); |
| } |
| return null; |
| }; |
| AbstractJsEmitterVisitor.prototype.visitFunctionExpr = function (ast, ctx) { |
| ctx.print(ast, "function" + (ast.name ? ' ' + ast.name : '') + "("); |
| this._visitParams(ast.params, ctx); |
| ctx.println(ast, ") {"); |
| ctx.incIndent(); |
| this.visitAllStatements(ast.statements, ctx); |
| ctx.decIndent(); |
| ctx.print(ast, "}"); |
| return null; |
| }; |
| AbstractJsEmitterVisitor.prototype.visitDeclareFunctionStmt = function (stmt, ctx) { |
| ctx.print(stmt, "function " + stmt.name + "("); |
| this._visitParams(stmt.params, ctx); |
| ctx.println(stmt, ") {"); |
| ctx.incIndent(); |
| this.visitAllStatements(stmt.statements, ctx); |
| ctx.decIndent(); |
| ctx.println(stmt, "}"); |
| return null; |
| }; |
| AbstractJsEmitterVisitor.prototype.visitTryCatchStmt = function (stmt, ctx) { |
| ctx.println(stmt, "try {"); |
| ctx.incIndent(); |
| this.visitAllStatements(stmt.bodyStmts, ctx); |
| ctx.decIndent(); |
| ctx.println(stmt, "} catch (" + CATCH_ERROR_VAR$1.name + ") {"); |
| ctx.incIndent(); |
| var catchStmts = [CATCH_STACK_VAR$1.set(CATCH_ERROR_VAR$1.prop('stack')).toDeclStmt(null, [ |
| exports.StmtModifier.Final |
| ])].concat(stmt.catchStmts); |
| this.visitAllStatements(catchStmts, ctx); |
| ctx.decIndent(); |
| ctx.println(stmt, "}"); |
| return null; |
| }; |
| AbstractJsEmitterVisitor.prototype._visitParams = function (params, ctx) { |
| this.visitAllObjects(function (param) { return ctx.print(null, param.name); }, params, ctx, ','); |
| }; |
| AbstractJsEmitterVisitor.prototype.getBuiltinMethodName = function (method) { |
| var name; |
| switch (method) { |
| case exports.BuiltinMethod.ConcatArray: |
| name = 'concat'; |
| break; |
| case exports.BuiltinMethod.SubscribeObservable: |
| name = 'subscribe'; |
| break; |
| case exports.BuiltinMethod.Bind: |
| name = 'bind'; |
| break; |
| default: |
| throw new Error("Unknown builtin method: " + method); |
| } |
| return name; |
| }; |
| return AbstractJsEmitterVisitor; |
| }(AbstractEmitterVisitor)); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * A helper class to manage the evaluation of JIT generated code. |
| */ |
| var JitEvaluator = /** @class */ (function () { |
| function JitEvaluator() { |
| } |
| /** |
| * |
| * @param sourceUrl The URL of the generated code. |
| * @param statements An array of Angular statement AST nodes to be evaluated. |
| * @param reflector A helper used when converting the statements to executable code. |
| * @param createSourceMaps If true then create a source-map for the generated code and include it |
| * inline as a source-map comment. |
| * @returns A map of all the variables in the generated code. |
| */ |
| JitEvaluator.prototype.evaluateStatements = function (sourceUrl, statements, reflector, createSourceMaps) { |
| var converter = new JitEmitterVisitor(reflector); |
| var ctx = EmitterVisitorContext.createRoot(); |
| // Ensure generated code is in strict mode |
| if (statements.length > 0 && !isUseStrictStatement(statements[0])) { |
| statements = __spread([ |
| literal('use strict').toStmt() |
| ], statements); |
| } |
| converter.visitAllStatements(statements, ctx); |
| converter.createReturnStmt(ctx); |
| return this.evaluateCode(sourceUrl, ctx, converter.getArgs(), createSourceMaps); |
| }; |
| /** |
| * Evaluate a piece of JIT generated code. |
| * @param sourceUrl The URL of this generated code. |
| * @param ctx A context object that contains an AST of the code to be evaluated. |
| * @param vars A map containing the names and values of variables that the evaluated code might |
| * reference. |
| * @param createSourceMap If true then create a source-map for the generated code and include it |
| * inline as a source-map comment. |
| * @returns The result of evaluating the code. |
| */ |
| JitEvaluator.prototype.evaluateCode = function (sourceUrl, ctx, vars, createSourceMap) { |
| var fnBody = "\"use strict\";" + ctx.toSource() + "\n//# sourceURL=" + sourceUrl; |
| var fnArgNames = []; |
| var fnArgValues = []; |
| for (var argName in vars) { |
| fnArgValues.push(vars[argName]); |
| fnArgNames.push(argName); |
| } |
| if (createSourceMap) { |
| // using `new Function(...)` generates a header, 1 line of no arguments, 2 lines otherwise |
| // E.g. ``` |
| // function anonymous(a,b,c |
| // /**/) { ... }``` |
| // We don't want to hard code this fact, so we auto detect it via an empty function first. |
| var emptyFn = new (Function.bind.apply(Function, __spread([void 0], fnArgNames.concat('return null;'))))().toString(); |
| var headerLines = emptyFn.slice(0, emptyFn.indexOf('return null;')).split('\n').length - 1; |
| fnBody += "\n" + ctx.toSourceMapGenerator(sourceUrl, headerLines).toJsComment(); |
| } |
| var fn = new (Function.bind.apply(Function, __spread([void 0], fnArgNames.concat(fnBody))))(); |
| return this.executeFunction(fn, fnArgValues); |
| }; |
| /** |
| * Execute a JIT generated function by calling it. |
| * |
| * This method can be overridden in tests to capture the functions that are generated |
| * by this `JitEvaluator` class. |
| * |
| * @param fn A function to execute. |
| * @param args The arguments to pass to the function being executed. |
| * @returns The return value of the executed function. |
| */ |
| JitEvaluator.prototype.executeFunction = function (fn, args) { return fn.apply(void 0, __spread(args)); }; |
| return JitEvaluator; |
| }()); |
| /** |
| * An Angular AST visitor that converts AST nodes into executable JavaScript code. |
| */ |
| var JitEmitterVisitor = /** @class */ (function (_super) { |
| __extends(JitEmitterVisitor, _super); |
| function JitEmitterVisitor(reflector) { |
| var _this = _super.call(this) || this; |
| _this.reflector = reflector; |
| _this._evalArgNames = []; |
| _this._evalArgValues = []; |
| _this._evalExportedVars = []; |
| return _this; |
| } |
| JitEmitterVisitor.prototype.createReturnStmt = function (ctx) { |
| var stmt = new ReturnStatement(new LiteralMapExpr(this._evalExportedVars.map(function (resultVar) { return new LiteralMapEntry(resultVar, variable(resultVar), false); }))); |
| stmt.visitStatement(this, ctx); |
| }; |
| JitEmitterVisitor.prototype.getArgs = function () { |
| var result = {}; |
| for (var i = 0; i < this._evalArgNames.length; i++) { |
| result[this._evalArgNames[i]] = this._evalArgValues[i]; |
| } |
| return result; |
| }; |
| JitEmitterVisitor.prototype.visitExternalExpr = function (ast, ctx) { |
| this._emitReferenceToExternal(ast, this.reflector.resolveExternalReference(ast.value), ctx); |
| return null; |
| }; |
| JitEmitterVisitor.prototype.visitWrappedNodeExpr = function (ast, ctx) { |
| this._emitReferenceToExternal(ast, ast.node, ctx); |
| return null; |
| }; |
| JitEmitterVisitor.prototype.visitDeclareVarStmt = function (stmt, ctx) { |
| if (stmt.hasModifier(exports.StmtModifier.Exported)) { |
| this._evalExportedVars.push(stmt.name); |
| } |
| return _super.prototype.visitDeclareVarStmt.call(this, stmt, ctx); |
| }; |
| JitEmitterVisitor.prototype.visitDeclareFunctionStmt = function (stmt, ctx) { |
| if (stmt.hasModifier(exports.StmtModifier.Exported)) { |
| this._evalExportedVars.push(stmt.name); |
| } |
| return _super.prototype.visitDeclareFunctionStmt.call(this, stmt, ctx); |
| }; |
| JitEmitterVisitor.prototype.visitDeclareClassStmt = function (stmt, ctx) { |
| if (stmt.hasModifier(exports.StmtModifier.Exported)) { |
| this._evalExportedVars.push(stmt.name); |
| } |
| return _super.prototype.visitDeclareClassStmt.call(this, stmt, ctx); |
| }; |
| JitEmitterVisitor.prototype._emitReferenceToExternal = function (ast, value, ctx) { |
| var id = this._evalArgValues.indexOf(value); |
| if (id === -1) { |
| id = this._evalArgValues.length; |
| this._evalArgValues.push(value); |
| var name_1 = identifierName({ reference: value }) || 'val'; |
| this._evalArgNames.push("jit_" + name_1 + "_" + id); |
| } |
| ctx.print(ast, this._evalArgNames[id]); |
| }; |
| return JitEmitterVisitor; |
| }(AbstractJsEmitterVisitor)); |
| function isUseStrictStatement(statement) { |
| return statement.isEquivalent(literal('use strict').toStmt()); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * Implementation of `CompileReflector` which resolves references to @angular/core |
| * symbols at runtime, according to a consumer-provided mapping. |
| * |
| * Only supports `resolveExternalReference`, all other methods throw. |
| */ |
| var R3JitReflector = /** @class */ (function () { |
| function R3JitReflector(context) { |
| this.context = context; |
| } |
| R3JitReflector.prototype.resolveExternalReference = function (ref) { |
| // This reflector only handles @angular/core imports. |
| if (ref.moduleName !== '@angular/core') { |
| throw new Error("Cannot resolve external reference to " + ref.moduleName + ", only references to @angular/core are supported."); |
| } |
| if (!this.context.hasOwnProperty(ref.name)) { |
| throw new Error("No value provided for @angular/core symbol '" + ref.name + "'."); |
| } |
| return this.context[ref.name]; |
| }; |
| R3JitReflector.prototype.parameters = function (typeOrFunc) { throw new Error('Not implemented.'); }; |
| R3JitReflector.prototype.annotations = function (typeOrFunc) { throw new Error('Not implemented.'); }; |
| R3JitReflector.prototype.shallowAnnotations = function (typeOrFunc) { throw new Error('Not implemented.'); }; |
| R3JitReflector.prototype.tryAnnotations = function (typeOrFunc) { throw new Error('Not implemented.'); }; |
| R3JitReflector.prototype.propMetadata = function (typeOrFunc) { throw new Error('Not implemented.'); }; |
| R3JitReflector.prototype.hasLifecycleHook = function (type, lcProperty) { throw new Error('Not implemented.'); }; |
| R3JitReflector.prototype.guards = function (typeOrFunc) { throw new Error('Not implemented.'); }; |
| R3JitReflector.prototype.componentModuleUrl = function (type, cmpMetadata) { throw new Error('Not implemented.'); }; |
| return R3JitReflector; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * Construct an `R3NgModuleDef` for the given `R3NgModuleMetadata`. |
| */ |
| function compileNgModule(meta) { |
| var moduleType = meta.type, bootstrap = meta.bootstrap, declarations = meta.declarations, imports = meta.imports, exports = meta.exports, schemas = meta.schemas, containsForwardDecls = meta.containsForwardDecls, emitInline = meta.emitInline, id = meta.id; |
| var additionalStatements = []; |
| var definitionMap = { |
| type: moduleType |
| }; |
| // Only generate the keys in the metadata if the arrays have values. |
| if (bootstrap.length) { |
| definitionMap.bootstrap = refsToArray(bootstrap, containsForwardDecls); |
| } |
| // If requested to emit scope information inline, pass the declarations, imports and exports to |
| // the `ɵɵdefineNgModule` call. The JIT compilation uses this. |
| if (emitInline) { |
| if (declarations.length) { |
| definitionMap.declarations = refsToArray(declarations, containsForwardDecls); |
| } |
| if (imports.length) { |
| definitionMap.imports = refsToArray(imports, containsForwardDecls); |
| } |
| if (exports.length) { |
| definitionMap.exports = refsToArray(exports, containsForwardDecls); |
| } |
| } |
| // If not emitting inline, the scope information is not passed into `ɵɵdefineNgModule` as it would |
| // prevent tree-shaking of the declarations, imports and exports references. |
| else { |
| var setNgModuleScopeCall = generateSetNgModuleScopeCall(meta); |
| if (setNgModuleScopeCall !== null) { |
| additionalStatements.push(setNgModuleScopeCall); |
| } |
| } |
| if (schemas && schemas.length) { |
| definitionMap.schemas = literalArr(schemas.map(function (ref) { return ref.value; })); |
| } |
| if (id) { |
| definitionMap.id = id; |
| } |
| var expression = importExpr(Identifiers$1.defineNgModule).callFn([mapToMapExpression(definitionMap)]); |
| var type = new ExpressionType(importExpr(Identifiers$1.NgModuleDefWithMeta, [ |
| new ExpressionType(moduleType), tupleTypeOf(declarations), tupleTypeOf(imports), |
| tupleTypeOf(exports) |
| ])); |
| return { expression: expression, type: type, additionalStatements: additionalStatements }; |
| } |
| /** |
| * Generates a function call to `ɵɵsetNgModuleScope` with all necessary information so that the |
| * transitive module scope can be computed during runtime in JIT mode. This call is marked pure |
| * such that the references to declarations, imports and exports may be elided causing these |
| * symbols to become tree-shakeable. |
| */ |
| function generateSetNgModuleScopeCall(meta) { |
| var moduleType = meta.type, declarations = meta.declarations, imports = meta.imports, exports = meta.exports, containsForwardDecls = meta.containsForwardDecls; |
| var scopeMap = {}; |
| if (declarations.length) { |
| scopeMap.declarations = refsToArray(declarations, containsForwardDecls); |
| } |
| if (imports.length) { |
| scopeMap.imports = refsToArray(imports, containsForwardDecls); |
| } |
| if (exports.length) { |
| scopeMap.exports = refsToArray(exports, containsForwardDecls); |
| } |
| if (Object.keys(scopeMap).length === 0) { |
| return null; |
| } |
| var fnCall = new InvokeFunctionExpr( |
| /* fn */ importExpr(Identifiers$1.setNgModuleScope), |
| /* args */ [moduleType, mapToMapExpression(scopeMap)], |
| /* type */ undefined, |
| /* sourceSpan */ undefined, |
| /* pure */ true); |
| return fnCall.toStmt(); |
| } |
| function compileInjector(meta) { |
| var result = compileFactoryFunction({ |
| name: meta.name, |
| type: meta.type, |
| deps: meta.deps, |
| injectFn: Identifiers$1.inject, |
| }); |
| var definitionMap = { |
| factory: result.factory, |
| }; |
| if (meta.providers !== null) { |
| definitionMap.providers = meta.providers; |
| } |
| if (meta.imports.length > 0) { |
| definitionMap.imports = literalArr(meta.imports); |
| } |
| var expression = importExpr(Identifiers$1.defineInjector).callFn([mapToMapExpression(definitionMap)]); |
| var type = new ExpressionType(importExpr(Identifiers$1.InjectorDef, [new ExpressionType(meta.type)])); |
| return { expression: expression, type: type, statements: result.statements }; |
| } |
| // TODO(alxhub): integrate this with `compileNgModule`. Currently the two are separate operations. |
| function compileNgModuleFromRender2(ctx, ngModule, injectableCompiler) { |
| var className = identifierName(ngModule.type); |
| var rawImports = ngModule.rawImports ? [ngModule.rawImports] : []; |
| var rawExports = ngModule.rawExports ? [ngModule.rawExports] : []; |
| var injectorDefArg = mapLiteral({ |
| 'factory': injectableCompiler.factoryFor({ type: ngModule.type, symbol: ngModule.type.reference }, ctx), |
| 'providers': convertMetaToOutput(ngModule.rawProviders, ctx), |
| 'imports': convertMetaToOutput(__spread(rawImports, rawExports), ctx), |
| }); |
| var injectorDef = importExpr(Identifiers$1.defineInjector).callFn([injectorDefArg]); |
| ctx.statements.push(new ClassStmt( |
| /* name */ className, |
| /* parent */ null, |
| /* fields */ [new ClassField( |
| /* name */ 'ngInjectorDef', |
| /* type */ INFERRED_TYPE, |
| /* modifiers */ [exports.StmtModifier.Static], |
| /* initializer */ injectorDef)], |
| /* getters */ [], |
| /* constructorMethod */ new ClassMethod(null, [], []), |
| /* methods */ [])); |
| } |
| function tupleTypeOf(exp) { |
| var types = exp.map(function (ref) { return typeofExpr(ref.type); }); |
| return exp.length > 0 ? expressionType(literalArr(types)) : NONE_TYPE; |
| } |
| function refsToArray(refs, shouldForwardDeclare) { |
| var values = literalArr(refs.map(function (ref) { return ref.value; })); |
| return shouldForwardDeclare ? fn([], [new ReturnStatement(values)]) : values; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| function compilePipeFromMetadata(metadata) { |
| var definitionMapValues = []; |
| // e.g. `name: 'myPipe'` |
| definitionMapValues.push({ key: 'name', value: literal(metadata.pipeName), quoted: false }); |
| // e.g. `type: MyPipe` |
| definitionMapValues.push({ key: 'type', value: metadata.type, quoted: false }); |
| var templateFactory = compileFactoryFunction({ |
| name: metadata.name, |
| type: metadata.type, |
| deps: metadata.deps, |
| injectFn: Identifiers$1.directiveInject, |
| }); |
| definitionMapValues.push({ key: 'factory', value: templateFactory.factory, quoted: false }); |
| // e.g. `pure: true` |
| definitionMapValues.push({ key: 'pure', value: literal(metadata.pure), quoted: false }); |
| var expression = importExpr(Identifiers$1.definePipe).callFn([literalMap(definitionMapValues)]); |
| var type = new ExpressionType(importExpr(Identifiers$1.PipeDefWithMeta, [ |
| typeWithParameters(metadata.type, metadata.typeArgumentCount), |
| new ExpressionType(new LiteralExpr(metadata.pipeName)), |
| ])); |
| return { expression: expression, type: type, statements: templateFactory.statements }; |
| } |
| /** |
| * Write a pipe definition to the output context. |
| */ |
| function compilePipeFromRender2(outputCtx, pipe, reflector) { |
| var name = identifierName(pipe.type); |
| if (!name) { |
| return error("Cannot resolve the name of " + pipe.type); |
| } |
| var metadata = { |
| name: name, |
| pipeName: pipe.name, |
| type: outputCtx.importExpr(pipe.type.reference), |
| typeArgumentCount: 0, |
| deps: dependenciesFromGlobalMetadata(pipe.type, outputCtx, reflector), |
| pure: pipe.pure, |
| }; |
| var res = compilePipeFromMetadata(metadata); |
| var definitionField = outputCtx.constantPool.propertyNameOf(3 /* Pipe */); |
| outputCtx.statements.push(new ClassStmt( |
| /* name */ name, |
| /* parent */ null, |
| /* fields */ [new ClassField( |
| /* name */ definitionField, |
| /* type */ INFERRED_TYPE, |
| /* modifiers */ [exports.StmtModifier.Static], |
| /* initializer */ res.expression)], |
| /* getters */ [], |
| /* constructorMethod */ new ClassMethod(null, [], []), |
| /* methods */ [])); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var ParserError = /** @class */ (function () { |
| function ParserError(message, input, errLocation, ctxLocation) { |
| this.input = input; |
| this.errLocation = errLocation; |
| this.ctxLocation = ctxLocation; |
| this.message = "Parser Error: " + message + " " + errLocation + " [" + input + "] in " + ctxLocation; |
| } |
| return ParserError; |
| }()); |
| var ParseSpan = /** @class */ (function () { |
| function ParseSpan(start, end) { |
| this.start = start; |
| this.end = end; |
| } |
| return ParseSpan; |
| }()); |
| var AST = /** @class */ (function () { |
| function AST(span) { |
| this.span = span; |
| } |
| AST.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return null; |
| }; |
| AST.prototype.toString = function () { return 'AST'; }; |
| return AST; |
| }()); |
| /** |
| * Represents a quoted expression of the form: |
| * |
| * quote = prefix `:` uninterpretedExpression |
| * prefix = identifier |
| * uninterpretedExpression = arbitrary string |
| * |
| * A quoted expression is meant to be pre-processed by an AST transformer that |
| * converts it into another AST that no longer contains quoted expressions. |
| * It is meant to allow third-party developers to extend Angular template |
| * expression language. The `uninterpretedExpression` part of the quote is |
| * therefore not interpreted by the Angular's own expression parser. |
| */ |
| var Quote = /** @class */ (function (_super) { |
| __extends(Quote, _super); |
| function Quote(span, prefix, uninterpretedExpression, location) { |
| var _this = _super.call(this, span) || this; |
| _this.prefix = prefix; |
| _this.uninterpretedExpression = uninterpretedExpression; |
| _this.location = location; |
| return _this; |
| } |
| Quote.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitQuote(this, context); |
| }; |
| Quote.prototype.toString = function () { return 'Quote'; }; |
| return Quote; |
| }(AST)); |
| var EmptyExpr = /** @class */ (function (_super) { |
| __extends(EmptyExpr, _super); |
| function EmptyExpr() { |
| return _super !== null && _super.apply(this, arguments) || this; |
| } |
| EmptyExpr.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| // do nothing |
| }; |
| return EmptyExpr; |
| }(AST)); |
| var ImplicitReceiver = /** @class */ (function (_super) { |
| __extends(ImplicitReceiver, _super); |
| function ImplicitReceiver() { |
| return _super !== null && _super.apply(this, arguments) || this; |
| } |
| ImplicitReceiver.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitImplicitReceiver(this, context); |
| }; |
| return ImplicitReceiver; |
| }(AST)); |
| /** |
| * Multiple expressions separated by a semicolon. |
| */ |
| var Chain = /** @class */ (function (_super) { |
| __extends(Chain, _super); |
| function Chain(span, expressions) { |
| var _this = _super.call(this, span) || this; |
| _this.expressions = expressions; |
| return _this; |
| } |
| Chain.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitChain(this, context); |
| }; |
| return Chain; |
| }(AST)); |
| var Conditional = /** @class */ (function (_super) { |
| __extends(Conditional, _super); |
| function Conditional(span, condition, trueExp, falseExp) { |
| var _this = _super.call(this, span) || this; |
| _this.condition = condition; |
| _this.trueExp = trueExp; |
| _this.falseExp = falseExp; |
| return _this; |
| } |
| Conditional.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitConditional(this, context); |
| }; |
| return Conditional; |
| }(AST)); |
| var PropertyRead = /** @class */ (function (_super) { |
| __extends(PropertyRead, _super); |
| function PropertyRead(span, receiver, name) { |
| var _this = _super.call(this, span) || this; |
| _this.receiver = receiver; |
| _this.name = name; |
| return _this; |
| } |
| PropertyRead.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitPropertyRead(this, context); |
| }; |
| return PropertyRead; |
| }(AST)); |
| var PropertyWrite = /** @class */ (function (_super) { |
| __extends(PropertyWrite, _super); |
| function PropertyWrite(span, receiver, name, value) { |
| var _this = _super.call(this, span) || this; |
| _this.receiver = receiver; |
| _this.name = name; |
| _this.value = value; |
| return _this; |
| } |
| PropertyWrite.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitPropertyWrite(this, context); |
| }; |
| return PropertyWrite; |
| }(AST)); |
| var SafePropertyRead = /** @class */ (function (_super) { |
| __extends(SafePropertyRead, _super); |
| function SafePropertyRead(span, receiver, name) { |
| var _this = _super.call(this, span) || this; |
| _this.receiver = receiver; |
| _this.name = name; |
| return _this; |
| } |
| SafePropertyRead.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitSafePropertyRead(this, context); |
| }; |
| return SafePropertyRead; |
| }(AST)); |
| var KeyedRead = /** @class */ (function (_super) { |
| __extends(KeyedRead, _super); |
| function KeyedRead(span, obj, key) { |
| var _this = _super.call(this, span) || this; |
| _this.obj = obj; |
| _this.key = key; |
| return _this; |
| } |
| KeyedRead.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitKeyedRead(this, context); |
| }; |
| return KeyedRead; |
| }(AST)); |
| var KeyedWrite = /** @class */ (function (_super) { |
| __extends(KeyedWrite, _super); |
| function KeyedWrite(span, obj, key, value) { |
| var _this = _super.call(this, span) || this; |
| _this.obj = obj; |
| _this.key = key; |
| _this.value = value; |
| return _this; |
| } |
| KeyedWrite.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitKeyedWrite(this, context); |
| }; |
| return KeyedWrite; |
| }(AST)); |
| var BindingPipe = /** @class */ (function (_super) { |
| __extends(BindingPipe, _super); |
| function BindingPipe(span, exp, name, args) { |
| var _this = _super.call(this, span) || this; |
| _this.exp = exp; |
| _this.name = name; |
| _this.args = args; |
| return _this; |
| } |
| BindingPipe.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitPipe(this, context); |
| }; |
| return BindingPipe; |
| }(AST)); |
| var LiteralPrimitive = /** @class */ (function (_super) { |
| __extends(LiteralPrimitive, _super); |
| function LiteralPrimitive(span, value) { |
| var _this = _super.call(this, span) || this; |
| _this.value = value; |
| return _this; |
| } |
| LiteralPrimitive.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitLiteralPrimitive(this, context); |
| }; |
| return LiteralPrimitive; |
| }(AST)); |
| var LiteralArray = /** @class */ (function (_super) { |
| __extends(LiteralArray, _super); |
| function LiteralArray(span, expressions) { |
| var _this = _super.call(this, span) || this; |
| _this.expressions = expressions; |
| return _this; |
| } |
| LiteralArray.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitLiteralArray(this, context); |
| }; |
| return LiteralArray; |
| }(AST)); |
| var LiteralMap = /** @class */ (function (_super) { |
| __extends(LiteralMap, _super); |
| function LiteralMap(span, keys, values) { |
| var _this = _super.call(this, span) || this; |
| _this.keys = keys; |
| _this.values = values; |
| return _this; |
| } |
| LiteralMap.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitLiteralMap(this, context); |
| }; |
| return LiteralMap; |
| }(AST)); |
| var Interpolation = /** @class */ (function (_super) { |
| __extends(Interpolation, _super); |
| function Interpolation(span, strings, expressions) { |
| var _this = _super.call(this, span) || this; |
| _this.strings = strings; |
| _this.expressions = expressions; |
| return _this; |
| } |
| Interpolation.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitInterpolation(this, context); |
| }; |
| return Interpolation; |
| }(AST)); |
| var Binary = /** @class */ (function (_super) { |
| __extends(Binary, _super); |
| function Binary(span, operation, left, right) { |
| var _this = _super.call(this, span) || this; |
| _this.operation = operation; |
| _this.left = left; |
| _this.right = right; |
| return _this; |
| } |
| Binary.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitBinary(this, context); |
| }; |
| return Binary; |
| }(AST)); |
| var PrefixNot = /** @class */ (function (_super) { |
| __extends(PrefixNot, _super); |
| function PrefixNot(span, expression) { |
| var _this = _super.call(this, span) || this; |
| _this.expression = expression; |
| return _this; |
| } |
| PrefixNot.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitPrefixNot(this, context); |
| }; |
| return PrefixNot; |
| }(AST)); |
| var NonNullAssert = /** @class */ (function (_super) { |
| __extends(NonNullAssert, _super); |
| function NonNullAssert(span, expression) { |
| var _this = _super.call(this, span) || this; |
| _this.expression = expression; |
| return _this; |
| } |
| NonNullAssert.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitNonNullAssert(this, context); |
| }; |
| return NonNullAssert; |
| }(AST)); |
| var MethodCall = /** @class */ (function (_super) { |
| __extends(MethodCall, _super); |
| function MethodCall(span, receiver, name, args) { |
| var _this = _super.call(this, span) || this; |
| _this.receiver = receiver; |
| _this.name = name; |
| _this.args = args; |
| return _this; |
| } |
| MethodCall.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitMethodCall(this, context); |
| }; |
| return MethodCall; |
| }(AST)); |
| var SafeMethodCall = /** @class */ (function (_super) { |
| __extends(SafeMethodCall, _super); |
| function SafeMethodCall(span, receiver, name, args) { |
| var _this = _super.call(this, span) || this; |
| _this.receiver = receiver; |
| _this.name = name; |
| _this.args = args; |
| return _this; |
| } |
| SafeMethodCall.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitSafeMethodCall(this, context); |
| }; |
| return SafeMethodCall; |
| }(AST)); |
| var FunctionCall = /** @class */ (function (_super) { |
| __extends(FunctionCall, _super); |
| function FunctionCall(span, target, args) { |
| var _this = _super.call(this, span) || this; |
| _this.target = target; |
| _this.args = args; |
| return _this; |
| } |
| FunctionCall.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return visitor.visitFunctionCall(this, context); |
| }; |
| return FunctionCall; |
| }(AST)); |
| var ASTWithSource = /** @class */ (function (_super) { |
| __extends(ASTWithSource, _super); |
| function ASTWithSource(ast, source, location, errors) { |
| var _this = _super.call(this, new ParseSpan(0, source == null ? 0 : source.length)) || this; |
| _this.ast = ast; |
| _this.source = source; |
| _this.location = location; |
| _this.errors = errors; |
| return _this; |
| } |
| ASTWithSource.prototype.visit = function (visitor, context) { |
| if (context === void 0) { context = null; } |
| return this.ast.visit(visitor, context); |
| }; |
| ASTWithSource.prototype.toString = function () { return this.source + " in " + this.location; }; |
| return ASTWithSource; |
| }(AST)); |
| var TemplateBinding = /** @class */ (function () { |
| function TemplateBinding(span, key, keyIsVar, name, expression) { |
| this.span = span; |
| this.key = key; |
| this.keyIsVar = keyIsVar; |
| this.name = name; |
| this.expression = expression; |
| } |
| return TemplateBinding; |
| }()); |
| var NullAstVisitor = /** @class */ (function () { |
| function NullAstVisitor() { |
| } |
| NullAstVisitor.prototype.visitBinary = function (ast, context) { }; |
| NullAstVisitor.prototype.visitChain = function (ast, context) { }; |
| NullAstVisitor.prototype.visitConditional = function (ast, context) { }; |
| NullAstVisitor.prototype.visitFunctionCall = function (ast, context) { }; |
| NullAstVisitor.prototype.visitImplicitReceiver = function (ast, context) { }; |
| NullAstVisitor.prototype.visitInterpolation = function (ast, context) { }; |
| NullAstVisitor.prototype.visitKeyedRead = function (ast, context) { }; |
| NullAstVisitor.prototype.visitKeyedWrite = function (ast, context) { }; |
| NullAstVisitor.prototype.visitLiteralArray = function (ast, context) { }; |
| NullAstVisitor.prototype.visitLiteralMap = function (ast, context) { }; |
| NullAstVisitor.prototype.visitLiteralPrimitive = function (ast, context) { }; |
| NullAstVisitor.prototype.visitMethodCall = function (ast, context) { }; |
| NullAstVisitor.prototype.visitPipe = function (ast, context) { }; |
| NullAstVisitor.prototype.visitPrefixNot = function (ast, context) { }; |
| NullAstVisitor.prototype.visitNonNullAssert = function (ast, context) { }; |
| NullAstVisitor.prototype.visitPropertyRead = function (ast, context) { }; |
| NullAstVisitor.prototype.visitPropertyWrite = function (ast, context) { }; |
| NullAstVisitor.prototype.visitQuote = function (ast, context) { }; |
| NullAstVisitor.prototype.visitSafeMethodCall = function (ast, context) { }; |
| NullAstVisitor.prototype.visitSafePropertyRead = function (ast, context) { }; |
| return NullAstVisitor; |
| }()); |
| var RecursiveAstVisitor$1 = /** @class */ (function () { |
| function RecursiveAstVisitor() { |
| } |
| RecursiveAstVisitor.prototype.visitBinary = function (ast, context) { |
| ast.left.visit(this, context); |
| ast.right.visit(this, context); |
| return null; |
| }; |
| RecursiveAstVisitor.prototype.visitChain = function (ast, context) { return this.visitAll(ast.expressions, context); }; |
| RecursiveAstVisitor.prototype.visitConditional = function (ast, context) { |
| ast.condition.visit(this, context); |
| ast.trueExp.visit(this, context); |
| ast.falseExp.visit(this, context); |
| return null; |
| }; |
| RecursiveAstVisitor.prototype.visitPipe = function (ast, context) { |
| ast.exp.visit(this, context); |
| this.visitAll(ast.args, context); |
| return null; |
| }; |
| RecursiveAstVisitor.prototype.visitFunctionCall = function (ast, context) { |
| ast.target.visit(this, context); |
| this.visitAll(ast.args, context); |
| return null; |
| }; |
| RecursiveAstVisitor.prototype.visitImplicitReceiver = function (ast, context) { return null; }; |
| RecursiveAstVisitor.prototype.visitInterpolation = function (ast, context) { |
| return this.visitAll(ast.expressions, context); |
| }; |
| RecursiveAstVisitor.prototype.visitKeyedRead = function (ast, context) { |
| ast.obj.visit(this, context); |
| ast.key.visit(this, context); |
| return null; |
| }; |
| RecursiveAstVisitor.prototype.visitKeyedWrite = function (ast, context) { |
| ast.obj.visit(this, context); |
| ast.key.visit(this, context); |
| ast.value.visit(this, context); |
| return null; |
| }; |
| RecursiveAstVisitor.prototype.visitLiteralArray = function (ast, context) { |
| return this.visitAll(ast.expressions, context); |
| }; |
| RecursiveAstVisitor.prototype.visitLiteralMap = function (ast, context) { return this.visitAll(ast.values, context); }; |
| RecursiveAstVisitor.prototype.visitLiteralPrimitive = function (ast, context) { return null; }; |
| RecursiveAstVisitor.prototype.visitMethodCall = function (ast, context) { |
| ast.receiver.visit(this, context); |
| return this.visitAll(ast.args, context); |
| }; |
| RecursiveAstVisitor.prototype.visitPrefixNot = function (ast, context) { |
| ast.expression.visit(this, context); |
| return null; |
| }; |
| RecursiveAstVisitor.prototype.visitNonNullAssert = function (ast, context) { |
| ast.expression.visit(this, context); |
| return null; |
| }; |
| RecursiveAstVisitor.prototype.visitPropertyRead = function (ast, context) { |
| ast.receiver.visit(this, context); |
| return null; |
| }; |
| RecursiveAstVisitor.prototype.visitPropertyWrite = function (ast, context) { |
| ast.receiver.visit(this, context); |
| ast.value.visit(this, context); |
| return null; |
| }; |
| RecursiveAstVisitor.prototype.visitSafePropertyRead = function (ast, context) { |
| ast.receiver.visit(this, context); |
| return null; |
| }; |
| RecursiveAstVisitor.prototype.visitSafeMethodCall = function (ast, context) { |
| ast.receiver.visit(this, context); |
| return this.visitAll(ast.args, context); |
| }; |
| RecursiveAstVisitor.prototype.visitAll = function (asts, context) { |
| var _this = this; |
| asts.forEach(function (ast) { return ast.visit(_this, context); }); |
| return null; |
| }; |
| RecursiveAstVisitor.prototype.visitQuote = function (ast, context) { return null; }; |
| return RecursiveAstVisitor; |
| }()); |
| var AstTransformer$1 = /** @class */ (function () { |
| function AstTransformer() { |
| } |
| AstTransformer.prototype.visitImplicitReceiver = function (ast, context) { return ast; }; |
| AstTransformer.prototype.visitInterpolation = function (ast, context) { |
| return new Interpolation(ast.span, ast.strings, this.visitAll(ast.expressions)); |
| }; |
| AstTransformer.prototype.visitLiteralPrimitive = function (ast, context) { |
| return new LiteralPrimitive(ast.span, ast.value); |
| }; |
| AstTransformer.prototype.visitPropertyRead = function (ast, context) { |
| return new PropertyRead(ast.span, ast.receiver.visit(this), ast.name); |
| }; |
| AstTransformer.prototype.visitPropertyWrite = function (ast, context) { |
| return new PropertyWrite(ast.span, ast.receiver.visit(this), ast.name, ast.value.visit(this)); |
| }; |
| AstTransformer.prototype.visitSafePropertyRead = function (ast, context) { |
| return new SafePropertyRead(ast.span, ast.receiver.visit(this), ast.name); |
| }; |
| AstTransformer.prototype.visitMethodCall = function (ast, context) { |
| return new MethodCall(ast.span, ast.receiver.visit(this), ast.name, this.visitAll(ast.args)); |
| }; |
| AstTransformer.prototype.visitSafeMethodCall = function (ast, context) { |
| return new SafeMethodCall(ast.span, ast.receiver.visit(this), ast.name, this.visitAll(ast.args)); |
| }; |
| AstTransformer.prototype.visitFunctionCall = function (ast, context) { |
| return new FunctionCall(ast.span, ast.target.visit(this), this.visitAll(ast.args)); |
| }; |
| AstTransformer.prototype.visitLiteralArray = function (ast, context) { |
| return new LiteralArray(ast.span, this.visitAll(ast.expressions)); |
| }; |
| AstTransformer.prototype.visitLiteralMap = function (ast, context) { |
| return new LiteralMap(ast.span, ast.keys, this.visitAll(ast.values)); |
| }; |
| AstTransformer.prototype.visitBinary = function (ast, context) { |
| return new Binary(ast.span, ast.operation, ast.left.visit(this), ast.right.visit(this)); |
| }; |
| AstTransformer.prototype.visitPrefixNot = function (ast, context) { |
| return new PrefixNot(ast.span, ast.expression.visit(this)); |
| }; |
| AstTransformer.prototype.visitNonNullAssert = function (ast, context) { |
| return new NonNullAssert(ast.span, ast.expression.visit(this)); |
| }; |
| AstTransformer.prototype.visitConditional = function (ast, context) { |
| return new Conditional(ast.span, ast.condition.visit(this), ast.trueExp.visit(this), ast.falseExp.visit(this)); |
| }; |
| AstTransformer.prototype.visitPipe = function (ast, context) { |
| return new BindingPipe(ast.span, ast.exp.visit(this), ast.name, this.visitAll(ast.args)); |
| }; |
| AstTransformer.prototype.visitKeyedRead = function (ast, context) { |
| return new KeyedRead(ast.span, ast.obj.visit(this), ast.key.visit(this)); |
| }; |
| AstTransformer.prototype.visitKeyedWrite = function (ast, context) { |
| return new KeyedWrite(ast.span, ast.obj.visit(this), ast.key.visit(this), ast.value.visit(this)); |
| }; |
| AstTransformer.prototype.visitAll = function (asts) { |
| var res = new Array(asts.length); |
| for (var i = 0; i < asts.length; ++i) { |
| res[i] = asts[i].visit(this); |
| } |
| return res; |
| }; |
| AstTransformer.prototype.visitChain = function (ast, context) { |
| return new Chain(ast.span, this.visitAll(ast.expressions)); |
| }; |
| AstTransformer.prototype.visitQuote = function (ast, context) { |
| return new Quote(ast.span, ast.prefix, ast.uninterpretedExpression, ast.location); |
| }; |
| return AstTransformer; |
| }()); |
| // A transformer that only creates new nodes if the transformer makes a change or |
| // a change is made a child node. |
| var AstMemoryEfficientTransformer = /** @class */ (function () { |
| function AstMemoryEfficientTransformer() { |
| } |
| AstMemoryEfficientTransformer.prototype.visitImplicitReceiver = function (ast, context) { return ast; }; |
| AstMemoryEfficientTransformer.prototype.visitInterpolation = function (ast, context) { |
| var expressions = this.visitAll(ast.expressions); |
| if (expressions !== ast.expressions) |
| return new Interpolation(ast.span, ast.strings, expressions); |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitLiteralPrimitive = function (ast, context) { return ast; }; |
| AstMemoryEfficientTransformer.prototype.visitPropertyRead = function (ast, context) { |
| var receiver = ast.receiver.visit(this); |
| if (receiver !== ast.receiver) { |
| return new PropertyRead(ast.span, receiver, ast.name); |
| } |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitPropertyWrite = function (ast, context) { |
| var receiver = ast.receiver.visit(this); |
| var value = ast.value.visit(this); |
| if (receiver !== ast.receiver || value !== ast.value) { |
| return new PropertyWrite(ast.span, receiver, ast.name, value); |
| } |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitSafePropertyRead = function (ast, context) { |
| var receiver = ast.receiver.visit(this); |
| if (receiver !== ast.receiver) { |
| return new SafePropertyRead(ast.span, receiver, ast.name); |
| } |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitMethodCall = function (ast, context) { |
| var receiver = ast.receiver.visit(this); |
| var args = this.visitAll(ast.args); |
| if (receiver !== ast.receiver || args !== ast.args) { |
| return new MethodCall(ast.span, receiver, ast.name, args); |
| } |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitSafeMethodCall = function (ast, context) { |
| var receiver = ast.receiver.visit(this); |
| var args = this.visitAll(ast.args); |
| if (receiver !== ast.receiver || args !== ast.args) { |
| return new SafeMethodCall(ast.span, receiver, ast.name, args); |
| } |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitFunctionCall = function (ast, context) { |
| var target = ast.target && ast.target.visit(this); |
| var args = this.visitAll(ast.args); |
| if (target !== ast.target || args !== ast.args) { |
| return new FunctionCall(ast.span, target, args); |
| } |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitLiteralArray = function (ast, context) { |
| var expressions = this.visitAll(ast.expressions); |
| if (expressions !== ast.expressions) { |
| return new LiteralArray(ast.span, expressions); |
| } |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitLiteralMap = function (ast, context) { |
| var values = this.visitAll(ast.values); |
| if (values !== ast.values) { |
| return new LiteralMap(ast.span, ast.keys, values); |
| } |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitBinary = function (ast, context) { |
| var left = ast.left.visit(this); |
| var right = ast.right.visit(this); |
| if (left !== ast.left || right !== ast.right) { |
| return new Binary(ast.span, ast.operation, left, right); |
| } |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitPrefixNot = function (ast, context) { |
| var expression = ast.expression.visit(this); |
| if (expression !== ast.expression) { |
| return new PrefixNot(ast.span, expression); |
| } |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitNonNullAssert = function (ast, context) { |
| var expression = ast.expression.visit(this); |
| if (expression !== ast.expression) { |
| return new NonNullAssert(ast.span, expression); |
| } |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitConditional = function (ast, context) { |
| var condition = ast.condition.visit(this); |
| var trueExp = ast.trueExp.visit(this); |
| var falseExp = ast.falseExp.visit(this); |
| if (condition !== ast.condition || trueExp !== ast.trueExp || falseExp !== ast.falseExp) { |
| return new Conditional(ast.span, condition, trueExp, falseExp); |
| } |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitPipe = function (ast, context) { |
| var exp = ast.exp.visit(this); |
| var args = this.visitAll(ast.args); |
| if (exp !== ast.exp || args !== ast.args) { |
| return new BindingPipe(ast.span, exp, ast.name, args); |
| } |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitKeyedRead = function (ast, context) { |
| var obj = ast.obj.visit(this); |
| var key = ast.key.visit(this); |
| if (obj !== ast.obj || key !== ast.key) { |
| return new KeyedRead(ast.span, obj, key); |
| } |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitKeyedWrite = function (ast, context) { |
| var obj = ast.obj.visit(this); |
| var key = ast.key.visit(this); |
| var value = ast.value.visit(this); |
| if (obj !== ast.obj || key !== ast.key || value !== ast.value) { |
| return new KeyedWrite(ast.span, obj, key, value); |
| } |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitAll = function (asts) { |
| var res = new Array(asts.length); |
| var modified = false; |
| for (var i = 0; i < asts.length; ++i) { |
| var original = asts[i]; |
| var value = original.visit(this); |
| res[i] = value; |
| modified = modified || value !== original; |
| } |
| return modified ? res : asts; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitChain = function (ast, context) { |
| var expressions = this.visitAll(ast.expressions); |
| if (expressions !== ast.expressions) { |
| return new Chain(ast.span, expressions); |
| } |
| return ast; |
| }; |
| AstMemoryEfficientTransformer.prototype.visitQuote = function (ast, context) { return ast; }; |
| return AstMemoryEfficientTransformer; |
| }()); |
| function visitAstChildren(ast, visitor, context) { |
| function visit(ast) { |
| visitor.visit && visitor.visit(ast, context) || ast.visit(visitor, context); |
| } |
| function visitAll(asts) { asts.forEach(visit); } |
| ast.visit({ |
| visitBinary: function (ast) { |
| visit(ast.left); |
| visit(ast.right); |
| }, |
| visitChain: function (ast) { visitAll(ast.expressions); }, |
| visitConditional: function (ast) { |
| visit(ast.condition); |
| visit(ast.trueExp); |
| visit(ast.falseExp); |
| }, |
| visitFunctionCall: function (ast) { |
| if (ast.target) { |
| visit(ast.target); |
| } |
| visitAll(ast.args); |
| }, |
| visitImplicitReceiver: function (ast) { }, |
| visitInterpolation: function (ast) { visitAll(ast.expressions); }, |
| visitKeyedRead: function (ast) { |
| visit(ast.obj); |
| visit(ast.key); |
| }, |
| visitKeyedWrite: function (ast) { |
| visit(ast.obj); |
| visit(ast.key); |
| visit(ast.obj); |
| }, |
| visitLiteralArray: function (ast) { visitAll(ast.expressions); }, |
| visitLiteralMap: function (ast) { }, |
| visitLiteralPrimitive: function (ast) { }, |
| visitMethodCall: function (ast) { |
| visit(ast.receiver); |
| visitAll(ast.args); |
| }, |
| visitPipe: function (ast) { |
| visit(ast.exp); |
| visitAll(ast.args); |
| }, |
| visitPrefixNot: function (ast) { visit(ast.expression); }, |
| visitNonNullAssert: function (ast) { visit(ast.expression); }, |
| visitPropertyRead: function (ast) { visit(ast.receiver); }, |
| visitPropertyWrite: function (ast) { |
| visit(ast.receiver); |
| visit(ast.value); |
| }, |
| visitQuote: function (ast) { }, |
| visitSafeMethodCall: function (ast) { |
| visit(ast.receiver); |
| visitAll(ast.args); |
| }, |
| visitSafePropertyRead: function (ast) { visit(ast.receiver); }, |
| }); |
| } |
| // Bindings |
| var ParsedProperty = /** @class */ (function () { |
| function ParsedProperty(name, expression, type, sourceSpan) { |
| this.name = name; |
| this.expression = expression; |
| this.type = type; |
| this.sourceSpan = sourceSpan; |
| this.isLiteral = this.type === exports.ParsedPropertyType.LITERAL_ATTR; |
| this.isAnimation = this.type === exports.ParsedPropertyType.ANIMATION; |
| } |
| return ParsedProperty; |
| }()); |
| (function (ParsedPropertyType) { |
| ParsedPropertyType[ParsedPropertyType["DEFAULT"] = 0] = "DEFAULT"; |
| ParsedPropertyType[ParsedPropertyType["LITERAL_ATTR"] = 1] = "LITERAL_ATTR"; |
| ParsedPropertyType[ParsedPropertyType["ANIMATION"] = 2] = "ANIMATION"; |
| })(exports.ParsedPropertyType || (exports.ParsedPropertyType = {})); |
| var ParsedEvent = /** @class */ (function () { |
| // Regular events have a target |
| // Animation events have a phase |
| function ParsedEvent(name, targetOrPhase, type, handler, sourceSpan, handlerSpan) { |
| this.name = name; |
| this.targetOrPhase = targetOrPhase; |
| this.type = type; |
| this.handler = handler; |
| this.sourceSpan = sourceSpan; |
| this.handlerSpan = handlerSpan; |
| } |
| return ParsedEvent; |
| }()); |
| var ParsedVariable = /** @class */ (function () { |
| function ParsedVariable(name, value, sourceSpan) { |
| this.name = name; |
| this.value = value; |
| this.sourceSpan = sourceSpan; |
| } |
| return ParsedVariable; |
| }()); |
| var BoundElementProperty = /** @class */ (function () { |
| function BoundElementProperty(name, type, securityContext, value, unit, sourceSpan) { |
| this.name = name; |
| this.type = type; |
| this.securityContext = securityContext; |
| this.value = value; |
| this.unit = unit; |
| this.sourceSpan = sourceSpan; |
| } |
| return BoundElementProperty; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var EventHandlerVars = /** @class */ (function () { |
| function EventHandlerVars() { |
| } |
| EventHandlerVars.event = variable('$event'); |
| return EventHandlerVars; |
| }()); |
| var ConvertActionBindingResult = /** @class */ (function () { |
| function ConvertActionBindingResult( |
| /** |
| * Render2 compatible statements, |
| */ |
| stmts, |
| /** |
| * Variable name used with render2 compatible statements. |
| */ |
| allowDefault) { |
| this.stmts = stmts; |
| this.allowDefault = allowDefault; |
| /** |
| * This is bit of a hack. It converts statements which render2 expects to statements which are |
| * expected by render3. |
| * |
| * Example: `<div click="doSomething($event)">` will generate: |
| * |
| * Render3: |
| * ``` |
| * const pd_b:any = ((<any>ctx.doSomething($event)) !== false); |
| * return pd_b; |
| * ``` |
| * |
| * but render2 expects: |
| * ``` |
| * return ctx.doSomething($event); |
| * ``` |
| */ |
| // TODO(misko): remove this hack once we no longer support ViewEngine. |
| this.render3Stmts = stmts.map(function (statement) { |
| if (statement instanceof DeclareVarStmt && statement.name == allowDefault.name && |
| statement.value instanceof BinaryOperatorExpr) { |
| var lhs = statement.value.lhs; |
| return new ReturnStatement(lhs.value); |
| } |
| return statement; |
| }); |
| } |
| return ConvertActionBindingResult; |
| }()); |
| /** |
| * Converts the given expression AST into an executable output AST, assuming the expression is |
| * used in an action binding (e.g. an event handler). |
| */ |
| function convertActionBinding(localResolver, implicitReceiver, action, bindingId, interpolationFunction, baseSourceSpan) { |
| if (!localResolver) { |
| localResolver = new DefaultLocalResolver(); |
| } |
| var actionWithoutBuiltins = convertPropertyBindingBuiltins({ |
| createLiteralArrayConverter: function (argCount) { |
| // Note: no caching for literal arrays in actions. |
| return function (args) { return literalArr(args); }; |
| }, |
| createLiteralMapConverter: function (keys) { |
| // Note: no caching for literal maps in actions. |
| return function (values) { |
| var entries = keys.map(function (k, i) { return ({ |
| key: k.key, |
| value: values[i], |
| quoted: k.quoted, |
| }); }); |
| return literalMap(entries); |
| }; |
| }, |
| createPipeConverter: function (name) { |
| throw new Error("Illegal State: Actions are not allowed to contain pipes. Pipe: " + name); |
| } |
| }, action); |
| var visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, interpolationFunction, baseSourceSpan); |
| var actionStmts = []; |
| flattenStatements(actionWithoutBuiltins.visit(visitor, _Mode.Statement), actionStmts); |
| prependTemporaryDecls(visitor.temporaryCount, bindingId, actionStmts); |
| if (visitor.usesImplicitReceiver) { |
| localResolver.notifyImplicitReceiverUse(); |
| } |
| var lastIndex = actionStmts.length - 1; |
| var preventDefaultVar = null; |
| if (lastIndex >= 0) { |
| var lastStatement = actionStmts[lastIndex]; |
| var returnExpr = convertStmtIntoExpression(lastStatement); |
| if (returnExpr) { |
| // Note: We need to cast the result of the method call to dynamic, |
| // as it might be a void method! |
| preventDefaultVar = createPreventDefaultVar(bindingId); |
| actionStmts[lastIndex] = |
| preventDefaultVar.set(returnExpr.cast(DYNAMIC_TYPE).notIdentical(literal(false))) |
| .toDeclStmt(null, [exports.StmtModifier.Final]); |
| } |
| } |
| return new ConvertActionBindingResult(actionStmts, preventDefaultVar); |
| } |
| function convertPropertyBindingBuiltins(converterFactory, ast) { |
| return convertBuiltins(converterFactory, ast); |
| } |
| var ConvertPropertyBindingResult = /** @class */ (function () { |
| function ConvertPropertyBindingResult(stmts, currValExpr) { |
| this.stmts = stmts; |
| this.currValExpr = currValExpr; |
| } |
| return ConvertPropertyBindingResult; |
| }()); |
| var BindingForm; |
| (function (BindingForm) { |
| // The general form of binding expression, supports all expressions. |
| BindingForm[BindingForm["General"] = 0] = "General"; |
| // Try to generate a simple binding (no temporaries or statements) |
| // otherwise generate a general binding |
| BindingForm[BindingForm["TrySimple"] = 1] = "TrySimple"; |
| })(BindingForm || (BindingForm = {})); |
| /** |
| * Converts the given expression AST into an executable output AST, assuming the expression |
| * is used in property binding. The expression has to be preprocessed via |
| * `convertPropertyBindingBuiltins`. |
| */ |
| function convertPropertyBinding(localResolver, implicitReceiver, expressionWithoutBuiltins, bindingId, form, interpolationFunction) { |
| if (!localResolver) { |
| localResolver = new DefaultLocalResolver(); |
| } |
| var currValExpr = createCurrValueExpr(bindingId); |
| var visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, interpolationFunction); |
| var outputExpr = expressionWithoutBuiltins.visit(visitor, _Mode.Expression); |
| var stmts = getStatementsFromVisitor(visitor, bindingId); |
| if (visitor.usesImplicitReceiver) { |
| localResolver.notifyImplicitReceiverUse(); |
| } |
| if (visitor.temporaryCount === 0 && form == BindingForm.TrySimple) { |
| return new ConvertPropertyBindingResult([], outputExpr); |
| } |
| stmts.push(currValExpr.set(outputExpr).toDeclStmt(DYNAMIC_TYPE, [exports.StmtModifier.Final])); |
| return new ConvertPropertyBindingResult(stmts, currValExpr); |
| } |
| /** |
| * Given some expression, such as a binding or interpolation expression, and a context expression to |
| * look values up on, visit each facet of the given expression resolving values from the context |
| * expression such that a list of arguments can be derived from the found values that can be used as |
| * arguments to an external update instruction. |
| * |
| * @param localResolver The resolver to use to look up expressions by name appropriately |
| * @param contextVariableExpression The expression representing the context variable used to create |
| * the final argument expressions |
| * @param expressionWithArgumentsToExtract The expression to visit to figure out what values need to |
| * be resolved and what arguments list to build. |
| * @param bindingId A name prefix used to create temporary variable names if they're needed for the |
| * arguments generated |
| * @returns An array of expressions that can be passed as arguments to instruction expressions like |
| * `o.importExpr(R3.propertyInterpolate).callFn(result)` |
| */ |
| function convertUpdateArguments(localResolver, contextVariableExpression, expressionWithArgumentsToExtract, bindingId) { |
| var visitor = new _AstToIrVisitor(localResolver, contextVariableExpression, bindingId, undefined); |
| var outputExpr = expressionWithArgumentsToExtract.visit(visitor, _Mode.Expression); |
| if (visitor.usesImplicitReceiver) { |
| localResolver.notifyImplicitReceiverUse(); |
| } |
| var stmts = getStatementsFromVisitor(visitor, bindingId); |
| // Removing the first argument, because it was a length for ViewEngine, not Ivy. |
| var args = outputExpr.args.slice(1); |
| if (expressionWithArgumentsToExtract instanceof Interpolation) { |
| // If we're dealing with an interpolation of 1 value with an empty prefix and suffix, reduce the |
| // args returned to just the value, because we're going to pass it to a special instruction. |
| var strings = expressionWithArgumentsToExtract.strings; |
| if (args.length === 3 && strings[0] === '' && strings[1] === '') { |
| // Single argument interpolate instructions. |
| args = [args[1]]; |
| } |
| else if (args.length >= 19) { |
| // 19 or more arguments must be passed to the `interpolateV`-style instructions, which accept |
| // an array of arguments |
| args = [literalArr(args)]; |
| } |
| } |
| return { stmts: stmts, args: args }; |
| } |
| function getStatementsFromVisitor(visitor, bindingId) { |
| var stmts = []; |
| for (var i = 0; i < visitor.temporaryCount; i++) { |
| stmts.push(temporaryDeclaration(bindingId, i)); |
| } |
| return stmts; |
| } |
| function convertBuiltins(converterFactory, ast) { |
| var visitor = new _BuiltinAstConverter(converterFactory); |
| return ast.visit(visitor); |
| } |
| function temporaryName(bindingId, temporaryNumber) { |
| return "tmp_" + bindingId + "_" + temporaryNumber; |
| } |
| function temporaryDeclaration(bindingId, temporaryNumber) { |
| return new DeclareVarStmt(temporaryName(bindingId, temporaryNumber), NULL_EXPR); |
| } |
| function prependTemporaryDecls(temporaryCount, bindingId, statements) { |
| for (var i = temporaryCount - 1; i >= 0; i--) { |
| statements.unshift(temporaryDeclaration(bindingId, i)); |
| } |
| } |
| var _Mode; |
| (function (_Mode) { |
| _Mode[_Mode["Statement"] = 0] = "Statement"; |
| _Mode[_Mode["Expression"] = 1] = "Expression"; |
| })(_Mode || (_Mode = {})); |
| function ensureStatementMode(mode, ast) { |
| if (mode !== _Mode.Statement) { |
| throw new Error("Expected a statement, but saw " + ast); |
| } |
| } |
| function ensureExpressionMode(mode, ast) { |
| if (mode !== _Mode.Expression) { |
| throw new Error("Expected an expression, but saw " + ast); |
| } |
| } |
| function convertToStatementIfNeeded(mode, expr) { |
| if (mode === _Mode.Statement) { |
| return expr.toStmt(); |
| } |
| else { |
| return expr; |
| } |
| } |
| var _BuiltinAstConverter = /** @class */ (function (_super) { |
| __extends(_BuiltinAstConverter, _super); |
| function _BuiltinAstConverter(_converterFactory) { |
| var _this = _super.call(this) || this; |
| _this._converterFactory = _converterFactory; |
| return _this; |
| } |
| _BuiltinAstConverter.prototype.visitPipe = function (ast, context) { |
| var _this = this; |
| var args = __spread([ast.exp], ast.args).map(function (ast) { return ast.visit(_this, context); }); |
| return new BuiltinFunctionCall(ast.span, args, this._converterFactory.createPipeConverter(ast.name, args.length)); |
| }; |
| _BuiltinAstConverter.prototype.visitLiteralArray = function (ast, context) { |
| var _this = this; |
| var args = ast.expressions.map(function (ast) { return ast.visit(_this, context); }); |
| return new BuiltinFunctionCall(ast.span, args, this._converterFactory.createLiteralArrayConverter(ast.expressions.length)); |
| }; |
| _BuiltinAstConverter.prototype.visitLiteralMap = function (ast, context) { |
| var _this = this; |
| var args = ast.values.map(function (ast) { return ast.visit(_this, context); }); |
| return new BuiltinFunctionCall(ast.span, args, this._converterFactory.createLiteralMapConverter(ast.keys)); |
| }; |
| return _BuiltinAstConverter; |
| }(AstTransformer$1)); |
| var _AstToIrVisitor = /** @class */ (function () { |
| function _AstToIrVisitor(_localResolver, _implicitReceiver, bindingId, interpolationFunction, baseSourceSpan) { |
| this._localResolver = _localResolver; |
| this._implicitReceiver = _implicitReceiver; |
| this.bindingId = bindingId; |
| this.interpolationFunction = interpolationFunction; |
| this.baseSourceSpan = baseSourceSpan; |
| this._nodeMap = new Map(); |
| this._resultMap = new Map(); |
| this._currentTemporary = 0; |
| this.temporaryCount = 0; |
| this.usesImplicitReceiver = false; |
| } |
| _AstToIrVisitor.prototype.visitBinary = function (ast, mode) { |
| var op; |
| switch (ast.operation) { |
| case '+': |
| op = exports.BinaryOperator.Plus; |
| break; |
| case '-': |
| op = exports.BinaryOperator.Minus; |
| break; |
| case '*': |
| op = exports.BinaryOperator.Multiply; |
| break; |
| case '/': |
| op = exports.BinaryOperator.Divide; |
| break; |
| case '%': |
| op = exports.BinaryOperator.Modulo; |
| break; |
| case '&&': |
| op = exports.BinaryOperator.And; |
| break; |
| case '||': |
| op = exports.BinaryOperator.Or; |
| break; |
| case '==': |
| op = exports.BinaryOperator.Equals; |
| break; |
| case '!=': |
| op = exports.BinaryOperator.NotEquals; |
| break; |
| case '===': |
| op = exports.BinaryOperator.Identical; |
| break; |
| case '!==': |
| op = exports.BinaryOperator.NotIdentical; |
| break; |
| case '<': |
| op = exports.BinaryOperator.Lower; |
| break; |
| case '>': |
| op = exports.BinaryOperator.Bigger; |
| break; |
| case '<=': |
| op = exports.BinaryOperator.LowerEquals; |
| break; |
| case '>=': |
| op = exports.BinaryOperator.BiggerEquals; |
| break; |
| default: |
| throw new Error("Unsupported operation " + ast.operation); |
| } |
| return convertToStatementIfNeeded(mode, new BinaryOperatorExpr(op, this._visit(ast.left, _Mode.Expression), this._visit(ast.right, _Mode.Expression), undefined, this.convertSourceSpan(ast.span))); |
| }; |
| _AstToIrVisitor.prototype.visitChain = function (ast, mode) { |
| ensureStatementMode(mode, ast); |
| return this.visitAll(ast.expressions, mode); |
| }; |
| _AstToIrVisitor.prototype.visitConditional = function (ast, mode) { |
| var value = this._visit(ast.condition, _Mode.Expression); |
| return convertToStatementIfNeeded(mode, value.conditional(this._visit(ast.trueExp, _Mode.Expression), this._visit(ast.falseExp, _Mode.Expression), this.convertSourceSpan(ast.span))); |
| }; |
| _AstToIrVisitor.prototype.visitPipe = function (ast, mode) { |
| throw new Error("Illegal state: Pipes should have been converted into functions. Pipe: " + ast.name); |
| }; |
| _AstToIrVisitor.prototype.visitFunctionCall = function (ast, mode) { |
| var convertedArgs = this.visitAll(ast.args, _Mode.Expression); |
| var fnResult; |
| if (ast instanceof BuiltinFunctionCall) { |
| fnResult = ast.converter(convertedArgs); |
| } |
| else { |
| fnResult = this._visit(ast.target, _Mode.Expression) |
| .callFn(convertedArgs, this.convertSourceSpan(ast.span)); |
| } |
| return convertToStatementIfNeeded(mode, fnResult); |
| }; |
| _AstToIrVisitor.prototype.visitImplicitReceiver = function (ast, mode) { |
| ensureExpressionMode(mode, ast); |
| this.usesImplicitReceiver = true; |
| return this._implicitReceiver; |
| }; |
| _AstToIrVisitor.prototype.visitInterpolation = function (ast, mode) { |
| ensureExpressionMode(mode, ast); |
| var args = [literal(ast.expressions.length)]; |
| for (var i = 0; i < ast.strings.length - 1; i++) { |
| args.push(literal(ast.strings[i])); |
| args.push(this._visit(ast.expressions[i], _Mode.Expression)); |
| } |
| args.push(literal(ast.strings[ast.strings.length - 1])); |
| if (this.interpolationFunction) { |
| return this.interpolationFunction(args); |
| } |
| return ast.expressions.length <= 9 ? |
| importExpr(Identifiers.inlineInterpolate).callFn(args) : |
| importExpr(Identifiers.interpolate).callFn([ |
| args[0], literalArr(args.slice(1), undefined, this.convertSourceSpan(ast.span)) |
| ]); |
| }; |
| _AstToIrVisitor.prototype.visitKeyedRead = function (ast, mode) { |
| var leftMostSafe = this.leftMostSafeNode(ast); |
| if (leftMostSafe) { |
| return this.convertSafeAccess(ast, leftMostSafe, mode); |
| } |
| else { |
| return convertToStatementIfNeeded(mode, this._visit(ast.obj, _Mode.Expression).key(this._visit(ast.key, _Mode.Expression))); |
| } |
| }; |
| _AstToIrVisitor.prototype.visitKeyedWrite = function (ast, mode) { |
| var obj = this._visit(ast.obj, _Mode.Expression); |
| var key = this._visit(ast.key, _Mode.Expression); |
| var value = this._visit(ast.value, _Mode.Expression); |
| return convertToStatementIfNeeded(mode, obj.key(key).set(value)); |
| }; |
| _AstToIrVisitor.prototype.visitLiteralArray = function (ast, mode) { |
| throw new Error("Illegal State: literal arrays should have been converted into functions"); |
| }; |
| _AstToIrVisitor.prototype.visitLiteralMap = function (ast, mode) { |
| throw new Error("Illegal State: literal maps should have been converted into functions"); |
| }; |
| _AstToIrVisitor.prototype.visitLiteralPrimitive = function (ast, mode) { |
| // For literal values of null, undefined, true, or false allow type interference |
| // to infer the type. |
| var type = ast.value === null || ast.value === undefined || ast.value === true || ast.value === true ? |
| INFERRED_TYPE : |
| undefined; |
| return convertToStatementIfNeeded(mode, literal(ast.value, type, this.convertSourceSpan(ast.span))); |
| }; |
| _AstToIrVisitor.prototype._getLocal = function (name) { return this._localResolver.getLocal(name); }; |
| _AstToIrVisitor.prototype.visitMethodCall = function (ast, mode) { |
| if (ast.receiver instanceof ImplicitReceiver && ast.name == '$any') { |
| var args = this.visitAll(ast.args, _Mode.Expression); |
| if (args.length != 1) { |
| throw new Error("Invalid call to $any, expected 1 argument but received " + (args.length || 'none')); |
| } |
| return args[0].cast(DYNAMIC_TYPE, this.convertSourceSpan(ast.span)); |
| } |
| var leftMostSafe = this.leftMostSafeNode(ast); |
| if (leftMostSafe) { |
| return this.convertSafeAccess(ast, leftMostSafe, mode); |
| } |
| else { |
| var args = this.visitAll(ast.args, _Mode.Expression); |
| var prevUsesImplicitReceiver = this.usesImplicitReceiver; |
| var result = null; |
| var receiver = this._visit(ast.receiver, _Mode.Expression); |
| if (receiver === this._implicitReceiver) { |
| var varExpr = this._getLocal(ast.name); |
| if (varExpr) { |
| // Restore the previous "usesImplicitReceiver" state since the implicit |
| // receiver has been replaced with a resolved local expression. |
| this.usesImplicitReceiver = prevUsesImplicitReceiver; |
| result = varExpr.callFn(args); |
| } |
| } |
| if (result == null) { |
| result = receiver.callMethod(ast.name, args, this.convertSourceSpan(ast.span)); |
| } |
| return convertToStatementIfNeeded(mode, result); |
| } |
| }; |
| _AstToIrVisitor.prototype.visitPrefixNot = function (ast, mode) { |
| return convertToStatementIfNeeded(mode, not(this._visit(ast.expression, _Mode.Expression))); |
| }; |
| _AstToIrVisitor.prototype.visitNonNullAssert = function (ast, mode) { |
| return convertToStatementIfNeeded(mode, assertNotNull(this._visit(ast.expression, _Mode.Expression))); |
| }; |
| _AstToIrVisitor.prototype.visitPropertyRead = function (ast, mode) { |
| var leftMostSafe = this.leftMostSafeNode(ast); |
| if (leftMostSafe) { |
| return this.convertSafeAccess(ast, leftMostSafe, mode); |
| } |
| else { |
| var result = null; |
| var prevUsesImplicitReceiver = this.usesImplicitReceiver; |
| var receiver = this._visit(ast.receiver, _Mode.Expression); |
| if (receiver === this._implicitReceiver) { |
| result = this._getLocal(ast.name); |
| if (result) { |
| // Restore the previous "usesImplicitReceiver" state since the implicit |
| // receiver has been replaced with a resolved local expression. |
| this.usesImplicitReceiver = prevUsesImplicitReceiver; |
| } |
| } |
| if (result == null) { |
| result = receiver.prop(ast.name); |
| } |
| return convertToStatementIfNeeded(mode, result); |
| } |
| }; |
| _AstToIrVisitor.prototype.visitPropertyWrite = function (ast, mode) { |
| var receiver = this._visit(ast.receiver, _Mode.Expression); |
| var prevUsesImplicitReceiver = this.usesImplicitReceiver; |
| var varExpr = null; |
| if (receiver === this._implicitReceiver) { |
| var localExpr = this._getLocal(ast.name); |
| if (localExpr) { |
| if (localExpr instanceof ReadPropExpr) { |
| // If the local variable is a property read expression, it's a reference |
| // to a 'context.property' value and will be used as the target of the |
| // write expression. |
| varExpr = localExpr; |
| // Restore the previous "usesImplicitReceiver" state since the implicit |
| // receiver has been replaced with a resolved local expression. |
| this.usesImplicitReceiver = prevUsesImplicitReceiver; |
| } |
| else { |
| // Otherwise it's an error. |
| throw new Error('Cannot assign to a reference or variable!'); |
| } |
| } |
| } |
| // If no local expression could be produced, use the original receiver's |
| // property as the target. |
| if (varExpr === null) { |
| varExpr = receiver.prop(ast.name); |
| } |
| return convertToStatementIfNeeded(mode, varExpr.set(this._visit(ast.value, _Mode.Expression))); |
| }; |
| _AstToIrVisitor.prototype.visitSafePropertyRead = function (ast, mode) { |
| return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode); |
| }; |
| _AstToIrVisitor.prototype.visitSafeMethodCall = function (ast, mode) { |
| return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode); |
| }; |
| _AstToIrVisitor.prototype.visitAll = function (asts, mode) { |
| var _this = this; |
| return asts.map(function (ast) { return _this._visit(ast, mode); }); |
| }; |
| _AstToIrVisitor.prototype.visitQuote = function (ast, mode) { |
| throw new Error("Quotes are not supported for evaluation!\n Statement: " + ast.uninterpretedExpression + " located at " + ast.location); |
| }; |
| _AstToIrVisitor.prototype._visit = function (ast, mode) { |
| var result = this._resultMap.get(ast); |
| if (result) |
| return result; |
| return (this._nodeMap.get(ast) || ast).visit(this, mode); |
| }; |
| _AstToIrVisitor.prototype.convertSafeAccess = function (ast, leftMostSafe, mode) { |
| // If the expression contains a safe access node on the left it needs to be converted to |
| // an expression that guards the access to the member by checking the receiver for blank. As |
| // execution proceeds from left to right, the left most part of the expression must be guarded |
| // first but, because member access is left associative, the right side of the expression is at |
| // the top of the AST. The desired result requires lifting a copy of the the left part of the |
| // expression up to test it for blank before generating the unguarded version. |
| // Consider, for example the following expression: a?.b.c?.d.e |
| // This results in the ast: |
| // . |
| // / \ |
| // ?. e |
| // / \ |
| // . d |
| // / \ |
| // ?. c |
| // / \ |
| // a b |
| // The following tree should be generated: |
| // |
| // /---- ? ----\ |
| // / | \ |
| // a /--- ? ---\ null |
| // / | \ |
| // . . null |
| // / \ / \ |
| // . c . e |
| // / \ / \ |
| // a b . d |
| // / \ |
| // . c |
| // / \ |
| // a b |
| // |
| // Notice that the first guard condition is the left hand of the left most safe access node |
| // which comes in as leftMostSafe to this routine. |
| var guardedExpression = this._visit(leftMostSafe.receiver, _Mode.Expression); |
| var temporary = undefined; |
| if (this.needsTemporary(leftMostSafe.receiver)) { |
| // If the expression has method calls or pipes then we need to save the result into a |
| // temporary variable to avoid calling stateful or impure code more than once. |
| temporary = this.allocateTemporary(); |
| // Preserve the result in the temporary variable |
| guardedExpression = temporary.set(guardedExpression); |
| // Ensure all further references to the guarded expression refer to the temporary instead. |
| this._resultMap.set(leftMostSafe.receiver, temporary); |
| } |
| var condition = guardedExpression.isBlank(); |
| // Convert the ast to an unguarded access to the receiver's member. The map will substitute |
| // leftMostNode with its unguarded version in the call to `this.visit()`. |
| if (leftMostSafe instanceof SafeMethodCall) { |
| this._nodeMap.set(leftMostSafe, new MethodCall(leftMostSafe.span, leftMostSafe.receiver, leftMostSafe.name, leftMostSafe.args)); |
| } |
| else { |
| this._nodeMap.set(leftMostSafe, new PropertyRead(leftMostSafe.span, leftMostSafe.receiver, leftMostSafe.name)); |
| } |
| // Recursively convert the node now without the guarded member access. |
| var access = this._visit(ast, _Mode.Expression); |
| // Remove the mapping. This is not strictly required as the converter only traverses each node |
| // once but is safer if the conversion is changed to traverse the nodes more than once. |
| this._nodeMap.delete(leftMostSafe); |
| // If we allocated a temporary, release it. |
| if (temporary) { |
| this.releaseTemporary(temporary); |
| } |
| // Produce the conditional |
| return convertToStatementIfNeeded(mode, condition.conditional(literal(null), access)); |
| }; |
| // Given a expression of the form a?.b.c?.d.e the the left most safe node is |
| // the (a?.b). The . and ?. are left associative thus can be rewritten as: |
| // ((((a?.c).b).c)?.d).e. This returns the most deeply nested safe read or |
| // safe method call as this needs be transform initially to: |
| // a == null ? null : a.c.b.c?.d.e |
| // then to: |
| // a == null ? null : a.b.c == null ? null : a.b.c.d.e |
| _AstToIrVisitor.prototype.leftMostSafeNode = function (ast) { |
| var _this = this; |
| var visit = function (visitor, ast) { |
| return (_this._nodeMap.get(ast) || ast).visit(visitor); |
| }; |
| return ast.visit({ |
| visitBinary: function (ast) { return null; }, |
| visitChain: function (ast) { return null; }, |
| visitConditional: function (ast) { return null; }, |
| visitFunctionCall: function (ast) { return null; }, |
| visitImplicitReceiver: function (ast) { return null; }, |
| visitInterpolation: function (ast) { return null; }, |
| visitKeyedRead: function (ast) { return visit(this, ast.obj); }, |
| visitKeyedWrite: function (ast) { return null; }, |
| visitLiteralArray: function (ast) { return null; }, |
| visitLiteralMap: function (ast) { return null; }, |
| visitLiteralPrimitive: function (ast) { return null; }, |
| visitMethodCall: function (ast) { return visit(this, ast.receiver); }, |
| visitPipe: function (ast) { return null; }, |
| visitPrefixNot: function (ast) { return null; }, |
| visitNonNullAssert: function (ast) { return null; }, |
| visitPropertyRead: function (ast) { return visit(this, ast.receiver); }, |
| visitPropertyWrite: function (ast) { return null; }, |
| visitQuote: function (ast) { return null; }, |
| visitSafeMethodCall: function (ast) { return visit(this, ast.receiver) || ast; }, |
| visitSafePropertyRead: function (ast) { |
| return visit(this, ast.receiver) || ast; |
| } |
| }); |
| }; |
| // Returns true of the AST includes a method or a pipe indicating that, if the |
| // expression is used as the target of a safe property or method access then |
| // the expression should be stored into a temporary variable. |
| _AstToIrVisitor.prototype.needsTemporary = function (ast) { |
| var _this = this; |
| var visit = function (visitor, ast) { |
| return ast && (_this._nodeMap.get(ast) || ast).visit(visitor); |
| }; |
| var visitSome = function (visitor, ast) { |
| return ast.some(function (ast) { return visit(visitor, ast); }); |
| }; |
| return ast.visit({ |
| visitBinary: function (ast) { return visit(this, ast.left) || visit(this, ast.right); }, |
| visitChain: function (ast) { return false; }, |
| visitConditional: function (ast) { |
| return visit(this, ast.condition) || visit(this, ast.trueExp) || |
| visit(this, ast.falseExp); |
| }, |
| visitFunctionCall: function (ast) { return true; }, |
| visitImplicitReceiver: function (ast) { return false; }, |
| visitInterpolation: function (ast) { return visitSome(this, ast.expressions); }, |
| visitKeyedRead: function (ast) { return false; }, |
| visitKeyedWrite: function (ast) { return false; }, |
| visitLiteralArray: function (ast) { return true; }, |
| visitLiteralMap: function (ast) { return true; }, |
| visitLiteralPrimitive: function (ast) { return false; }, |
| visitMethodCall: function (ast) { return true; }, |
| visitPipe: function (ast) { return true; }, |
| visitPrefixNot: function (ast) { return visit(this, ast.expression); }, |
| visitNonNullAssert: function (ast) { return visit(this, ast.expression); }, |
| visitPropertyRead: function (ast) { return false; }, |
| visitPropertyWrite: function (ast) { return false; }, |
| visitQuote: function (ast) { return false; }, |
| visitSafeMethodCall: function (ast) { return true; }, |
| visitSafePropertyRead: function (ast) { return false; } |
| }); |
| }; |
| _AstToIrVisitor.prototype.allocateTemporary = function () { |
| var tempNumber = this._currentTemporary++; |
| this.temporaryCount = Math.max(this._currentTemporary, this.temporaryCount); |
| return new ReadVarExpr(temporaryName(this.bindingId, tempNumber)); |
| }; |
| _AstToIrVisitor.prototype.releaseTemporary = function (temporary) { |
| this._currentTemporary--; |
| if (temporary.name != temporaryName(this.bindingId, this._currentTemporary)) { |
| throw new Error("Temporary " + temporary.name + " released out of order"); |
| } |
| }; |
| /** |
| * Creates an absolute `ParseSourceSpan` from the relative `ParseSpan`. |
| * |
| * `ParseSpan` objects are relative to the start of the expression. |
| * This method converts these to full `ParseSourceSpan` objects that |
| * show where the span is within the overall source file. |
| * |
| * @param span the relative span to convert. |
| * @returns a `ParseSourceSpan` for the the given span or null if no |
| * `baseSourceSpan` was provided to this class. |
| */ |
| _AstToIrVisitor.prototype.convertSourceSpan = function (span) { |
| if (this.baseSourceSpan) { |
| var start = this.baseSourceSpan.start.moveBy(span.start); |
| var end = this.baseSourceSpan.start.moveBy(span.end); |
| return new ParseSourceSpan(start, end); |
| } |
| else { |
| return null; |
| } |
| }; |
| return _AstToIrVisitor; |
| }()); |
| function flattenStatements(arg, output) { |
| if (Array.isArray(arg)) { |
| arg.forEach(function (entry) { return flattenStatements(entry, output); }); |
| } |
| else { |
| output.push(arg); |
| } |
| } |
| var DefaultLocalResolver = /** @class */ (function () { |
| function DefaultLocalResolver() { |
| } |
| DefaultLocalResolver.prototype.notifyImplicitReceiverUse = function () { }; |
| DefaultLocalResolver.prototype.getLocal = function (name) { |
| if (name === EventHandlerVars.event.name) { |
| return EventHandlerVars.event; |
| } |
| return null; |
| }; |
| return DefaultLocalResolver; |
| }()); |
| function createCurrValueExpr(bindingId) { |
| return variable("currVal_" + bindingId); // fix syntax highlighting: ` |
| } |
| function createPreventDefaultVar(bindingId) { |
| return variable("pd_" + bindingId); |
| } |
| function convertStmtIntoExpression(stmt) { |
| if (stmt instanceof ExpressionStatement) { |
| return stmt.expr; |
| } |
| else if (stmt instanceof ReturnStatement) { |
| return stmt.value; |
| } |
| return null; |
| } |
| var BuiltinFunctionCall = /** @class */ (function (_super) { |
| __extends(BuiltinFunctionCall, _super); |
| function BuiltinFunctionCall(span, args, converter) { |
| var _this = _super.call(this, span, null, args) || this; |
| _this.args = args; |
| _this.converter = converter; |
| return _this; |
| } |
| return BuiltinFunctionCall; |
| }(FunctionCall)); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * This file is a port of shadowCSS from webcomponents.js to TypeScript. |
| * |
| * Please make sure to keep to edits in sync with the source file. |
| * |
| * Source: |
| * https://github.com/webcomponents/webcomponentsjs/blob/4efecd7e0e/src/ShadowCSS/ShadowCSS.js |
| * |
| * The original file level comment is reproduced below |
| */ |
| /* |
| This is a limited shim for ShadowDOM css styling. |
| https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#styles |
| |
| The intention here is to support only the styling features which can be |
| relatively simply implemented. The goal is to allow users to avoid the |
| most obvious pitfalls and do so without compromising performance significantly. |
| For ShadowDOM styling that's not covered here, a set of best practices |
| can be provided that should allow users to accomplish more complex styling. |
| |
| The following is a list of specific ShadowDOM styling features and a brief |
| discussion of the approach used to shim. |
| |
| Shimmed features: |
| |
| * :host, :host-context: ShadowDOM allows styling of the shadowRoot's host |
| element using the :host rule. To shim this feature, the :host styles are |
| reformatted and prefixed with a given scope name and promoted to a |
| document level stylesheet. |
| For example, given a scope name of .foo, a rule like this: |
| |
| :host { |
| background: red; |
| } |
| } |
| |
| becomes: |
| |
| .foo { |
| background: red; |
| } |
| |
| * encapsulation: Styles defined within ShadowDOM, apply only to |
| dom inside the ShadowDOM. Polymer uses one of two techniques to implement |
| this feature. |
| |
| By default, rules are prefixed with the host element tag name |
| as a descendant selector. This ensures styling does not leak out of the 'top' |
| of the element's ShadowDOM. For example, |
| |
| div { |
| font-weight: bold; |
| } |
| |
| becomes: |
| |
| x-foo div { |
| font-weight: bold; |
| } |
| |
| becomes: |
| |
| |
| Alternatively, if WebComponents.ShadowCSS.strictStyling is set to true then |
| selectors are scoped by adding an attribute selector suffix to each |
| simple selector that contains the host element tag name. Each element |
| in the element's ShadowDOM template is also given the scope attribute. |
| Thus, these rules match only elements that have the scope attribute. |
| For example, given a scope name of x-foo, a rule like this: |
| |
| div { |
| font-weight: bold; |
| } |
| |
| becomes: |
| |
| div[x-foo] { |
| font-weight: bold; |
| } |
| |
| Note that elements that are dynamically added to a scope must have the scope |
| selector added to them manually. |
| |
| * upper/lower bound encapsulation: Styles which are defined outside a |
| shadowRoot should not cross the ShadowDOM boundary and should not apply |
| inside a shadowRoot. |
| |
| This styling behavior is not emulated. Some possible ways to do this that |
| were rejected due to complexity and/or performance concerns include: (1) reset |
| every possible property for every possible selector for a given scope name; |
| (2) re-implement css in javascript. |
| |
| As an alternative, users should make sure to use selectors |
| specific to the scope in which they are working. |
| |
| * ::distributed: This behavior is not emulated. It's often not necessary |
| to style the contents of a specific insertion point and instead, descendants |
| of the host element can be styled selectively. Users can also create an |
| extra node around an insertion point and style that node's contents |
| via descendent selectors. For example, with a shadowRoot like this: |
| |
| <style> |
| ::content(div) { |
| background: red; |
| } |
| </style> |
| <content></content> |
| |
| could become: |
| |
| <style> |
| / *@polyfill .content-container div * / |
| ::content(div) { |
| background: red; |
| } |
| </style> |
| <div class="content-container"> |
| <content></content> |
| </div> |
| |
| Note the use of @polyfill in the comment above a ShadowDOM specific style |
| declaration. This is a directive to the styling shim to use the selector |
| in comments in lieu of the next selector when running under polyfill. |
| */ |
| var ShadowCss = /** @class */ (function () { |
| function ShadowCss() { |
| this.strictStyling = true; |
| } |
| /* |
| * Shim some cssText with the given selector. Returns cssText that can |
| * be included in the document via WebComponents.ShadowCSS.addCssToDocument(css). |
| * |
| * When strictStyling is true: |
| * - selector is the attribute added to all elements inside the host, |
| * - hostSelector is the attribute added to the host itself. |
| */ |
| ShadowCss.prototype.shimCssText = function (cssText, selector, hostSelector) { |
| if (hostSelector === void 0) { hostSelector = ''; } |
| var commentsWithHash = extractCommentsWithHash(cssText); |
| cssText = stripComments(cssText); |
| cssText = this._insertDirectives(cssText); |
| var scopedCssText = this._scopeCssText(cssText, selector, hostSelector); |
| return __spread([scopedCssText], commentsWithHash).join('\n'); |
| }; |
| ShadowCss.prototype._insertDirectives = function (cssText) { |
| cssText = this._insertPolyfillDirectivesInCssText(cssText); |
| return this._insertPolyfillRulesInCssText(cssText); |
| }; |
| /* |
| * Process styles to convert native ShadowDOM rules that will trip |
| * up the css parser; we rely on decorating the stylesheet with inert rules. |
| * |
| * For example, we convert this rule: |
| * |
| * polyfill-next-selector { content: ':host menu-item'; } |
| * ::content menu-item { |
| * |
| * to this: |
| * |
| * scopeName menu-item { |
| * |
| **/ |
| ShadowCss.prototype._insertPolyfillDirectivesInCssText = function (cssText) { |
| // Difference with webcomponents.js: does not handle comments |
| return cssText.replace(_cssContentNextSelectorRe, function () { |
| var m = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| m[_i] = arguments[_i]; |
| } |
| return m[2] + '{'; |
| }); |
| }; |
| /* |
| * Process styles to add rules which will only apply under the polyfill |
| * |
| * For example, we convert this rule: |
| * |
| * polyfill-rule { |
| * content: ':host menu-item'; |
| * ... |
| * } |
| * |
| * to this: |
| * |
| * scopeName menu-item {...} |
| * |
| **/ |
| ShadowCss.prototype._insertPolyfillRulesInCssText = function (cssText) { |
| // Difference with webcomponents.js: does not handle comments |
| return cssText.replace(_cssContentRuleRe, function () { |
| var m = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| m[_i] = arguments[_i]; |
| } |
| var rule = m[0].replace(m[1], '').replace(m[2], ''); |
| return m[4] + rule; |
| }); |
| }; |
| /* Ensure styles are scoped. Pseudo-scoping takes a rule like: |
| * |
| * .foo {... } |
| * |
| * and converts this to |
| * |
| * scopeName .foo { ... } |
| */ |
| ShadowCss.prototype._scopeCssText = function (cssText, scopeSelector, hostSelector) { |
| var unscopedRules = this._extractUnscopedRulesFromCssText(cssText); |
| // replace :host and :host-context -shadowcsshost and -shadowcsshost respectively |
| cssText = this._insertPolyfillHostInCssText(cssText); |
| cssText = this._convertColonHost(cssText); |
| cssText = this._convertColonHostContext(cssText); |
| cssText = this._convertShadowDOMSelectors(cssText); |
| if (scopeSelector) { |
| cssText = this._scopeSelectors(cssText, scopeSelector, hostSelector); |
| } |
| cssText = cssText + '\n' + unscopedRules; |
| return cssText.trim(); |
| }; |
| /* |
| * Process styles to add rules which will only apply under the polyfill |
| * and do not process via CSSOM. (CSSOM is destructive to rules on rare |
| * occasions, e.g. -webkit-calc on Safari.) |
| * For example, we convert this rule: |
| * |
| * @polyfill-unscoped-rule { |
| * content: 'menu-item'; |
| * ... } |
| * |
| * to this: |
| * |
| * menu-item {...} |
| * |
| **/ |
| ShadowCss.prototype._extractUnscopedRulesFromCssText = function (cssText) { |
| // Difference with webcomponents.js: does not handle comments |
| var r = ''; |
| var m; |
| _cssContentUnscopedRuleRe.lastIndex = 0; |
| while ((m = _cssContentUnscopedRuleRe.exec(cssText)) !== null) { |
| var rule = m[0].replace(m[2], '').replace(m[1], m[4]); |
| r += rule + '\n\n'; |
| } |
| return r; |
| }; |
| /* |
| * convert a rule like :host(.foo) > .bar { } |
| * |
| * to |
| * |
| * .foo<scopeName> > .bar |
| */ |
| ShadowCss.prototype._convertColonHost = function (cssText) { |
| return this._convertColonRule(cssText, _cssColonHostRe, this._colonHostPartReplacer); |
| }; |
| /* |
| * convert a rule like :host-context(.foo) > .bar { } |
| * |
| * to |
| * |
| * .foo<scopeName> > .bar, .foo scopeName > .bar { } |
| * |
| * and |
| * |
| * :host-context(.foo:host) .bar { ... } |
| * |
| * to |
| * |
| * .foo<scopeName> .bar { ... } |
| */ |
| ShadowCss.prototype._convertColonHostContext = function (cssText) { |
| return this._convertColonRule(cssText, _cssColonHostContextRe, this._colonHostContextPartReplacer); |
| }; |
| ShadowCss.prototype._convertColonRule = function (cssText, regExp, partReplacer) { |
| // m[1] = :host(-context), m[2] = contents of (), m[3] rest of rule |
| return cssText.replace(regExp, function () { |
| var m = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| m[_i] = arguments[_i]; |
| } |
| if (m[2]) { |
| var parts = m[2].split(','); |
| var r = []; |
| for (var i = 0; i < parts.length; i++) { |
| var p = parts[i].trim(); |
| if (!p) |
| break; |
| r.push(partReplacer(_polyfillHostNoCombinator, p, m[3])); |
| } |
| return r.join(','); |
| } |
| else { |
| return _polyfillHostNoCombinator + m[3]; |
| } |
| }); |
| }; |
| ShadowCss.prototype._colonHostContextPartReplacer = function (host, part, suffix) { |
| if (part.indexOf(_polyfillHost) > -1) { |
| return this._colonHostPartReplacer(host, part, suffix); |
| } |
| else { |
| return host + part + suffix + ', ' + part + ' ' + host + suffix; |
| } |
| }; |
| ShadowCss.prototype._colonHostPartReplacer = function (host, part, suffix) { |
| return host + part.replace(_polyfillHost, '') + suffix; |
| }; |
| /* |
| * Convert combinators like ::shadow and pseudo-elements like ::content |
| * by replacing with space. |
| */ |
| ShadowCss.prototype._convertShadowDOMSelectors = function (cssText) { |
| return _shadowDOMSelectorsRe.reduce(function (result, pattern) { return result.replace(pattern, ' '); }, cssText); |
| }; |
| // change a selector like 'div' to 'name div' |
| ShadowCss.prototype._scopeSelectors = function (cssText, scopeSelector, hostSelector) { |
| var _this = this; |
| return processRules(cssText, function (rule) { |
| var selector = rule.selector; |
| var content = rule.content; |
| if (rule.selector[0] != '@') { |
| selector = |
| _this._scopeSelector(rule.selector, scopeSelector, hostSelector, _this.strictStyling); |
| } |
| else if (rule.selector.startsWith('@media') || rule.selector.startsWith('@supports') || |
| rule.selector.startsWith('@page') || rule.selector.startsWith('@document')) { |
| content = _this._scopeSelectors(rule.content, scopeSelector, hostSelector); |
| } |
| return new CssRule(selector, content); |
| }); |
| }; |
| ShadowCss.prototype._scopeSelector = function (selector, scopeSelector, hostSelector, strict) { |
| var _this = this; |
| return selector.split(',') |
| .map(function (part) { return part.trim().split(_shadowDeepSelectors); }) |
| .map(function (deepParts) { |
| var _a = __read(deepParts), shallowPart = _a[0], otherParts = _a.slice(1); |
| var applyScope = function (shallowPart) { |
| if (_this._selectorNeedsScoping(shallowPart, scopeSelector)) { |
| return strict ? |
| _this._applyStrictSelectorScope(shallowPart, scopeSelector, hostSelector) : |
| _this._applySelectorScope(shallowPart, scopeSelector, hostSelector); |
| } |
| else { |
| return shallowPart; |
| } |
| }; |
| return __spread([applyScope(shallowPart)], otherParts).join(' '); |
| }) |
| .join(', '); |
| }; |
| ShadowCss.prototype._selectorNeedsScoping = function (selector, scopeSelector) { |
| var re = this._makeScopeMatcher(scopeSelector); |
| return !re.test(selector); |
| }; |
| ShadowCss.prototype._makeScopeMatcher = function (scopeSelector) { |
| var lre = /\[/g; |
| var rre = /\]/g; |
| scopeSelector = scopeSelector.replace(lre, '\\[').replace(rre, '\\]'); |
| return new RegExp('^(' + scopeSelector + ')' + _selectorReSuffix, 'm'); |
| }; |
| ShadowCss.prototype._applySelectorScope = function (selector, scopeSelector, hostSelector) { |
| // Difference from webcomponents.js: scopeSelector could not be an array |
| return this._applySimpleSelectorScope(selector, scopeSelector, hostSelector); |
| }; |
| // scope via name and [is=name] |
| ShadowCss.prototype._applySimpleSelectorScope = function (selector, scopeSelector, hostSelector) { |
| // In Android browser, the lastIndex is not reset when the regex is used in String.replace() |
| _polyfillHostRe.lastIndex = 0; |
| if (_polyfillHostRe.test(selector)) { |
| var replaceBy_1 = this.strictStyling ? "[" + hostSelector + "]" : scopeSelector; |
| return selector |
| .replace(_polyfillHostNoCombinatorRe, function (hnc, selector) { |
| return selector.replace(/([^:]*)(:*)(.*)/, function (_, before, colon, after) { |
| return before + replaceBy_1 + colon + after; |
| }); |
| }) |
| .replace(_polyfillHostRe, replaceBy_1 + ' '); |
| } |
| return scopeSelector + ' ' + selector; |
| }; |
| // return a selector with [name] suffix on each simple selector |
| // e.g. .foo.bar > .zot becomes .foo[name].bar[name] > .zot[name] /** @internal */ |
| ShadowCss.prototype._applyStrictSelectorScope = function (selector, scopeSelector, hostSelector) { |
| var _this = this; |
| var isRe = /\[is=([^\]]*)\]/g; |
| scopeSelector = scopeSelector.replace(isRe, function (_) { |
| var parts = []; |
| for (var _i = 1; _i < arguments.length; _i++) { |
| parts[_i - 1] = arguments[_i]; |
| } |
| return parts[0]; |
| }); |
| var attrName = '[' + scopeSelector + ']'; |
| var _scopeSelectorPart = function (p) { |
| var scopedP = p.trim(); |
| if (!scopedP) { |
| return ''; |
| } |
| if (p.indexOf(_polyfillHostNoCombinator) > -1) { |
| scopedP = _this._applySimpleSelectorScope(p, scopeSelector, hostSelector); |
| } |
| else { |
| // remove :host since it should be unnecessary |
| var t = p.replace(_polyfillHostRe, ''); |
| if (t.length > 0) { |
| var matches = t.match(/([^:]*)(:*)(.*)/); |
| if (matches) { |
| scopedP = matches[1] + attrName + matches[2] + matches[3]; |
| } |
| } |
| } |
| return scopedP; |
| }; |
| var safeContent = new SafeSelector(selector); |
| selector = safeContent.content(); |
| var scopedSelector = ''; |
| var startIndex = 0; |
| var res; |
| var sep = /( |>|\+|~(?!=))\s*/g; |
| // If a selector appears before :host it should not be shimmed as it |
| // matches on ancestor elements and not on elements in the host's shadow |
| // `:host-context(div)` is transformed to |
| // `-shadowcsshost-no-combinatordiv, div -shadowcsshost-no-combinator` |
| // the `div` is not part of the component in the 2nd selectors and should not be scoped. |
| // Historically `component-tag:host` was matching the component so we also want to preserve |
| // this behavior to avoid breaking legacy apps (it should not match). |
| // The behavior should be: |
| // - `tag:host` -> `tag[h]` (this is to avoid breaking legacy apps, should not match anything) |
| // - `tag :host` -> `tag [h]` (`tag` is not scoped because it's considered part of a |
| // `:host-context(tag)`) |
| var hasHost = selector.indexOf(_polyfillHostNoCombinator) > -1; |
| // Only scope parts after the first `-shadowcsshost-no-combinator` when it is present |
| var shouldScope = !hasHost; |
| while ((res = sep.exec(selector)) !== null) { |
| var separator = res[1]; |
| var part_1 = selector.slice(startIndex, res.index).trim(); |
| shouldScope = shouldScope || part_1.indexOf(_polyfillHostNoCombinator) > -1; |
| var scopedPart = shouldScope ? _scopeSelectorPart(part_1) : part_1; |
| scopedSelector += scopedPart + " " + separator + " "; |
| startIndex = sep.lastIndex; |
| } |
| var part = selector.substring(startIndex); |
| shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1; |
| scopedSelector += shouldScope ? _scopeSelectorPart(part) : part; |
| // replace the placeholders with their original values |
| return safeContent.restore(scopedSelector); |
| }; |
| ShadowCss.prototype._insertPolyfillHostInCssText = function (selector) { |
| return selector.replace(_colonHostContextRe, _polyfillHostContext) |
| .replace(_colonHostRe, _polyfillHost); |
| }; |
| return ShadowCss; |
| }()); |
| var SafeSelector = /** @class */ (function () { |
| function SafeSelector(selector) { |
| var _this = this; |
| this.placeholders = []; |
| this.index = 0; |
| // Replaces attribute selectors with placeholders. |
| // The WS in [attr="va lue"] would otherwise be interpreted as a selector separator. |
| selector = selector.replace(/(\[[^\]]*\])/g, function (_, keep) { |
| var replaceBy = "__ph-" + _this.index + "__"; |
| _this.placeholders.push(keep); |
| _this.index++; |
| return replaceBy; |
| }); |
| // Replaces the expression in `:nth-child(2n + 1)` with a placeholder. |
| // WS and "+" would otherwise be interpreted as selector separators. |
| this._content = selector.replace(/(:nth-[-\w]+)(\([^)]+\))/g, function (_, pseudo, exp) { |
| var replaceBy = "__ph-" + _this.index + "__"; |
| _this.placeholders.push(exp); |
| _this.index++; |
| return pseudo + replaceBy; |
| }); |
| } |
| SafeSelector.prototype.restore = function (content) { |
| var _this = this; |
| return content.replace(/__ph-(\d+)__/g, function (ph, index) { return _this.placeholders[+index]; }); |
| }; |
| SafeSelector.prototype.content = function () { return this._content; }; |
| return SafeSelector; |
| }()); |
| var _cssContentNextSelectorRe = /polyfill-next-selector[^}]*content:[\s]*?(['"])(.*?)\1[;\s]*}([^{]*?){/gim; |
| var _cssContentRuleRe = /(polyfill-rule)[^}]*(content:[\s]*(['"])(.*?)\3)[;\s]*[^}]*}/gim; |
| var _cssContentUnscopedRuleRe = /(polyfill-unscoped-rule)[^}]*(content:[\s]*(['"])(.*?)\3)[;\s]*[^}]*}/gim; |
| var _polyfillHost = '-shadowcsshost'; |
| // note: :host-context pre-processed to -shadowcsshostcontext. |
| var _polyfillHostContext = '-shadowcsscontext'; |
| var _parenSuffix = ')(?:\\((' + |
| '(?:\\([^)(]*\\)|[^)(]*)+?' + |
| ')\\))?([^,{]*)'; |
| var _cssColonHostRe = new RegExp('(' + _polyfillHost + _parenSuffix, 'gim'); |
| var _cssColonHostContextRe = new RegExp('(' + _polyfillHostContext + _parenSuffix, 'gim'); |
| var _polyfillHostNoCombinator = _polyfillHost + '-no-combinator'; |
| var _polyfillHostNoCombinatorRe = /-shadowcsshost-no-combinator([^\s]*)/; |
| var _shadowDOMSelectorsRe = [ |
| /::shadow/g, |
| /::content/g, |
| // Deprecated selectors |
| /\/shadow-deep\//g, |
| /\/shadow\//g, |
| ]; |
| // The deep combinator is deprecated in the CSS spec |
| // Support for `>>>`, `deep`, `::ng-deep` is then also deprecated and will be removed in the future. |
| // see https://github.com/angular/angular/pull/17677 |
| var _shadowDeepSelectors = /(?:>>>)|(?:\/deep\/)|(?:::ng-deep)/g; |
| var _selectorReSuffix = '([>\\s~+\[.,{:][\\s\\S]*)?$'; |
| var _polyfillHostRe = /-shadowcsshost/gim; |
| var _colonHostRe = /:host/gim; |
| var _colonHostContextRe = /:host-context/gim; |
| var _commentRe = /\/\*\s*[\s\S]*?\*\//g; |
| function stripComments(input) { |
| return input.replace(_commentRe, ''); |
| } |
| var _commentWithHashRe = /\/\*\s*#\s*source(Mapping)?URL=[\s\S]+?\*\//g; |
| function extractCommentsWithHash(input) { |
| return input.match(_commentWithHashRe) || []; |
| } |
| var _ruleRe = /(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g; |
| var _curlyRe = /([{}])/g; |
| var OPEN_CURLY = '{'; |
| var CLOSE_CURLY = '}'; |
| var BLOCK_PLACEHOLDER = '%BLOCK%'; |
| var CssRule = /** @class */ (function () { |
| function CssRule(selector, content) { |
| this.selector = selector; |
| this.content = content; |
| } |
| return CssRule; |
| }()); |
| function processRules(input, ruleCallback) { |
| var inputWithEscapedBlocks = escapeBlocks(input); |
| var nextBlockIndex = 0; |
| return inputWithEscapedBlocks.escapedString.replace(_ruleRe, function () { |
| var m = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| m[_i] = arguments[_i]; |
| } |
| var selector = m[2]; |
| var content = ''; |
| var suffix = m[4]; |
| var contentPrefix = ''; |
| if (suffix && suffix.startsWith('{' + BLOCK_PLACEHOLDER)) { |
| content = inputWithEscapedBlocks.blocks[nextBlockIndex++]; |
| suffix = suffix.substring(BLOCK_PLACEHOLDER.length + 1); |
| contentPrefix = '{'; |
| } |
| var rule = ruleCallback(new CssRule(selector, content)); |
| return "" + m[1] + rule.selector + m[3] + contentPrefix + rule.content + suffix; |
| }); |
| } |
| var StringWithEscapedBlocks = /** @class */ (function () { |
| function StringWithEscapedBlocks(escapedString, blocks) { |
| this.escapedString = escapedString; |
| this.blocks = blocks; |
| } |
| return StringWithEscapedBlocks; |
| }()); |
| function escapeBlocks(input) { |
| var inputParts = input.split(_curlyRe); |
| var resultParts = []; |
| var escapedBlocks = []; |
| var bracketCount = 0; |
| var currentBlockParts = []; |
| for (var partIndex = 0; partIndex < inputParts.length; partIndex++) { |
| var part = inputParts[partIndex]; |
| if (part == CLOSE_CURLY) { |
| bracketCount--; |
| } |
| if (bracketCount > 0) { |
| currentBlockParts.push(part); |
| } |
| else { |
| if (currentBlockParts.length > 0) { |
| escapedBlocks.push(currentBlockParts.join('')); |
| resultParts.push(BLOCK_PLACEHOLDER); |
| currentBlockParts = []; |
| } |
| resultParts.push(part); |
| } |
| if (part == OPEN_CURLY) { |
| bracketCount++; |
| } |
| } |
| if (currentBlockParts.length > 0) { |
| escapedBlocks.push(currentBlockParts.join('')); |
| resultParts.push(BLOCK_PLACEHOLDER); |
| } |
| return new StringWithEscapedBlocks(resultParts.join(''), escapedBlocks); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var COMPONENT_VARIABLE = '%COMP%'; |
| var HOST_ATTR = "_nghost-" + COMPONENT_VARIABLE; |
| var CONTENT_ATTR = "_ngcontent-" + COMPONENT_VARIABLE; |
| var StylesCompileDependency = /** @class */ (function () { |
| function StylesCompileDependency(name, moduleUrl, setValue) { |
| this.name = name; |
| this.moduleUrl = moduleUrl; |
| this.setValue = setValue; |
| } |
| return StylesCompileDependency; |
| }()); |
| var CompiledStylesheet = /** @class */ (function () { |
| function CompiledStylesheet(outputCtx, stylesVar, dependencies, isShimmed, meta) { |
| this.outputCtx = outputCtx; |
| this.stylesVar = stylesVar; |
| this.dependencies = dependencies; |
| this.isShimmed = isShimmed; |
| this.meta = meta; |
| } |
| return CompiledStylesheet; |
| }()); |
| var StyleCompiler = /** @class */ (function () { |
| function StyleCompiler(_urlResolver) { |
| this._urlResolver = _urlResolver; |
| this._shadowCss = new ShadowCss(); |
| } |
| StyleCompiler.prototype.compileComponent = function (outputCtx, comp) { |
| var template = comp.template; |
| return this._compileStyles(outputCtx, comp, new CompileStylesheetMetadata({ |
| styles: template.styles, |
| styleUrls: template.styleUrls, |
| moduleUrl: identifierModuleUrl(comp.type) |
| }), this.needsStyleShim(comp), true); |
| }; |
| StyleCompiler.prototype.compileStyles = function (outputCtx, comp, stylesheet, shim) { |
| if (shim === void 0) { shim = this.needsStyleShim(comp); } |
| return this._compileStyles(outputCtx, comp, stylesheet, shim, false); |
| }; |
| StyleCompiler.prototype.needsStyleShim = function (comp) { |
| return comp.template.encapsulation === ViewEncapsulation.Emulated; |
| }; |
| StyleCompiler.prototype._compileStyles = function (outputCtx, comp, stylesheet, shim, isComponentStylesheet) { |
| var _this = this; |
| var styleExpressions = stylesheet.styles.map(function (plainStyle) { return literal(_this._shimIfNeeded(plainStyle, shim)); }); |
| var dependencies = []; |
| stylesheet.styleUrls.forEach(function (styleUrl) { |
| var exprIndex = styleExpressions.length; |
| // Note: This placeholder will be filled later. |
| styleExpressions.push(null); |
| dependencies.push(new StylesCompileDependency(getStylesVarName(null), styleUrl, function (value) { return styleExpressions[exprIndex] = outputCtx.importExpr(value); })); |
| }); |
| // styles variable contains plain strings and arrays of other styles arrays (recursive), |
| // so we set its type to dynamic. |
| var stylesVar = getStylesVarName(isComponentStylesheet ? comp : null); |
| var stmt = variable(stylesVar) |
| .set(literalArr(styleExpressions, new ArrayType(DYNAMIC_TYPE, [TypeModifier.Const]))) |
| .toDeclStmt(null, isComponentStylesheet ? [exports.StmtModifier.Final] : [ |
| exports.StmtModifier.Final, exports.StmtModifier.Exported |
| ]); |
| outputCtx.statements.push(stmt); |
| return new CompiledStylesheet(outputCtx, stylesVar, dependencies, shim, stylesheet); |
| }; |
| StyleCompiler.prototype._shimIfNeeded = function (style, shim) { |
| return shim ? this._shadowCss.shimCssText(style, CONTENT_ATTR, HOST_ATTR) : style; |
| }; |
| return StyleCompiler; |
| }()); |
| function getStylesVarName(component) { |
| var result = "styles"; |
| if (component) { |
| result += "_" + identifierName(component.type); |
| } |
| return result; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * A path is an ordered set of elements. Typically a path is to a |
| * particular offset in a source file. The head of the list is the top |
| * most node. The tail is the node that contains the offset directly. |
| * |
| * For example, the expression `a + b + c` might have an ast that looks |
| * like: |
| * + |
| * / \ |
| * a + |
| * / \ |
| * b c |
| * |
| * The path to the node at offset 9 would be `['+' at 1-10, '+' at 7-10, |
| * 'c' at 9-10]` and the path the node at offset 1 would be |
| * `['+' at 1-10, 'a' at 1-2]`. |
| */ |
| var AstPath = /** @class */ (function () { |
| function AstPath(path, position) { |
| if (position === void 0) { position = -1; } |
| this.path = path; |
| this.position = position; |
| } |
| Object.defineProperty(AstPath.prototype, "empty", { |
| get: function () { return !this.path || !this.path.length; }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(AstPath.prototype, "head", { |
| get: function () { return this.path[0]; }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(AstPath.prototype, "tail", { |
| get: function () { return this.path[this.path.length - 1]; }, |
| enumerable: true, |
| configurable: true |
| }); |
| AstPath.prototype.parentOf = function (node) { |
| return node && this.path[this.path.indexOf(node) - 1]; |
| }; |
| AstPath.prototype.childOf = function (node) { return this.path[this.path.indexOf(node) + 1]; }; |
| AstPath.prototype.first = function (ctor) { |
| for (var i = this.path.length - 1; i >= 0; i--) { |
| var item = this.path[i]; |
| if (item instanceof ctor) |
| return item; |
| } |
| }; |
| AstPath.prototype.push = function (node) { this.path.push(node); }; |
| AstPath.prototype.pop = function () { return this.path.pop(); }; |
| return AstPath; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var Text$3 = /** @class */ (function () { |
| function Text(value, sourceSpan, i18n) { |
| this.value = value; |
| this.sourceSpan = sourceSpan; |
| this.i18n = i18n; |
| } |
| Text.prototype.visit = function (visitor, context) { return visitor.visitText(this, context); }; |
| return Text; |
| }()); |
| var Expansion = /** @class */ (function () { |
| function Expansion(switchValue, type, cases, sourceSpan, switchValueSourceSpan, i18n) { |
| this.switchValue = switchValue; |
| this.type = type; |
| this.cases = cases; |
| this.sourceSpan = sourceSpan; |
| this.switchValueSourceSpan = switchValueSourceSpan; |
| this.i18n = i18n; |
| } |
| Expansion.prototype.visit = function (visitor, context) { return visitor.visitExpansion(this, context); }; |
| return Expansion; |
| }()); |
| var ExpansionCase = /** @class */ (function () { |
| function ExpansionCase(value, expression, sourceSpan, valueSourceSpan, expSourceSpan) { |
| this.value = value; |
| this.expression = expression; |
| this.sourceSpan = sourceSpan; |
| this.valueSourceSpan = valueSourceSpan; |
| this.expSourceSpan = expSourceSpan; |
| } |
| ExpansionCase.prototype.visit = function (visitor, context) { return visitor.visitExpansionCase(this, context); }; |
| return ExpansionCase; |
| }()); |
| var Attribute = /** @class */ (function () { |
| function Attribute(name, value, sourceSpan, valueSpan, i18n) { |
| this.name = name; |
| this.value = value; |
| this.sourceSpan = sourceSpan; |
| this.valueSpan = valueSpan; |
| this.i18n = i18n; |
| } |
| Attribute.prototype.visit = function (visitor, context) { return visitor.visitAttribute(this, context); }; |
| return Attribute; |
| }()); |
| var Element$1 = /** @class */ (function () { |
| function Element(name, attrs, children, sourceSpan, startSourceSpan, endSourceSpan, i18n) { |
| if (startSourceSpan === void 0) { startSourceSpan = null; } |
| if (endSourceSpan === void 0) { endSourceSpan = null; } |
| this.name = name; |
| this.attrs = attrs; |
| this.children = children; |
| this.sourceSpan = sourceSpan; |
| this.startSourceSpan = startSourceSpan; |
| this.endSourceSpan = endSourceSpan; |
| this.i18n = i18n; |
| } |
| Element.prototype.visit = function (visitor, context) { return visitor.visitElement(this, context); }; |
| return Element; |
| }()); |
| var Comment = /** @class */ (function () { |
| function Comment(value, sourceSpan) { |
| this.value = value; |
| this.sourceSpan = sourceSpan; |
| } |
| Comment.prototype.visit = function (visitor, context) { return visitor.visitComment(this, context); }; |
| return Comment; |
| }()); |
| function visitAll$1(visitor, nodes, context) { |
| if (context === void 0) { context = null; } |
| var result = []; |
| var visit = visitor.visit ? |
| function (ast) { return visitor.visit(ast, context) || ast.visit(visitor, context); } : |
| function (ast) { return ast.visit(visitor, context); }; |
| nodes.forEach(function (ast) { |
| var astResult = visit(ast); |
| if (astResult) { |
| result.push(astResult); |
| } |
| }); |
| return result; |
| } |
| var RecursiveVisitor = /** @class */ (function () { |
| function RecursiveVisitor() { |
| } |
| RecursiveVisitor.prototype.visitElement = function (ast, context) { |
| this.visitChildren(context, function (visit) { |
| visit(ast.attrs); |
| visit(ast.children); |
| }); |
| }; |
| RecursiveVisitor.prototype.visitAttribute = function (ast, context) { }; |
| RecursiveVisitor.prototype.visitText = function (ast, context) { }; |
| RecursiveVisitor.prototype.visitComment = function (ast, context) { }; |
| RecursiveVisitor.prototype.visitExpansion = function (ast, context) { |
| return this.visitChildren(context, function (visit) { visit(ast.cases); }); |
| }; |
| RecursiveVisitor.prototype.visitExpansionCase = function (ast, context) { }; |
| RecursiveVisitor.prototype.visitChildren = function (context, cb) { |
| var results = []; |
| var t = this; |
| function visit(children) { |
| if (children) |
| results.push(visitAll$1(t, children, context)); |
| } |
| cb(visit); |
| return [].concat.apply([], results); |
| }; |
| return RecursiveVisitor; |
| }()); |
| function spanOf(ast) { |
| var start = ast.sourceSpan.start.offset; |
| var end = ast.sourceSpan.end.offset; |
| if (ast instanceof Element$1) { |
| if (ast.endSourceSpan) { |
| end = ast.endSourceSpan.end.offset; |
| } |
| else if (ast.children && ast.children.length) { |
| end = spanOf(ast.children[ast.children.length - 1]).end; |
| } |
| } |
| return { start: start, end: end }; |
| } |
| function findNode(nodes, position) { |
| var path = []; |
| var visitor = new /** @class */ (function (_super) { |
| __extends(class_1, _super); |
| function class_1() { |
| return _super !== null && _super.apply(this, arguments) || this; |
| } |
| class_1.prototype.visit = function (ast, context) { |
| var span = spanOf(ast); |
| if (span.start <= position && position < span.end) { |
| path.push(ast); |
| } |
| else { |
| // Returning a value here will result in the children being skipped. |
| return true; |
| } |
| }; |
| return class_1; |
| }(RecursiveVisitor)); |
| visitAll$1(visitor, nodes); |
| return new AstPath(path, position); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var TokenType; |
| (function (TokenType) { |
| TokenType[TokenType["TAG_OPEN_START"] = 0] = "TAG_OPEN_START"; |
| TokenType[TokenType["TAG_OPEN_END"] = 1] = "TAG_OPEN_END"; |
| TokenType[TokenType["TAG_OPEN_END_VOID"] = 2] = "TAG_OPEN_END_VOID"; |
| TokenType[TokenType["TAG_CLOSE"] = 3] = "TAG_CLOSE"; |
| TokenType[TokenType["TEXT"] = 4] = "TEXT"; |
| TokenType[TokenType["ESCAPABLE_RAW_TEXT"] = 5] = "ESCAPABLE_RAW_TEXT"; |
| TokenType[TokenType["RAW_TEXT"] = 6] = "RAW_TEXT"; |
| TokenType[TokenType["COMMENT_START"] = 7] = "COMMENT_START"; |
| TokenType[TokenType["COMMENT_END"] = 8] = "COMMENT_END"; |
| TokenType[TokenType["CDATA_START"] = 9] = "CDATA_START"; |
| TokenType[TokenType["CDATA_END"] = 10] = "CDATA_END"; |
| TokenType[TokenType["ATTR_NAME"] = 11] = "ATTR_NAME"; |
| TokenType[TokenType["ATTR_QUOTE"] = 12] = "ATTR_QUOTE"; |
| TokenType[TokenType["ATTR_VALUE"] = 13] = "ATTR_VALUE"; |
| TokenType[TokenType["DOC_TYPE"] = 14] = "DOC_TYPE"; |
| TokenType[TokenType["EXPANSION_FORM_START"] = 15] = "EXPANSION_FORM_START"; |
| TokenType[TokenType["EXPANSION_CASE_VALUE"] = 16] = "EXPANSION_CASE_VALUE"; |
| TokenType[TokenType["EXPANSION_CASE_EXP_START"] = 17] = "EXPANSION_CASE_EXP_START"; |
| TokenType[TokenType["EXPANSION_CASE_EXP_END"] = 18] = "EXPANSION_CASE_EXP_END"; |
| TokenType[TokenType["EXPANSION_FORM_END"] = 19] = "EXPANSION_FORM_END"; |
| TokenType[TokenType["EOF"] = 20] = "EOF"; |
| })(TokenType || (TokenType = {})); |
| var Token = /** @class */ (function () { |
| function Token(type, parts, sourceSpan) { |
| this.type = type; |
| this.parts = parts; |
| this.sourceSpan = sourceSpan; |
| } |
| return Token; |
| }()); |
| var TokenError = /** @class */ (function (_super) { |
| __extends(TokenError, _super); |
| function TokenError(errorMsg, tokenType, span) { |
| var _this = _super.call(this, span, errorMsg) || this; |
| _this.tokenType = tokenType; |
| return _this; |
| } |
| return TokenError; |
| }(ParseError)); |
| var TokenizeResult = /** @class */ (function () { |
| function TokenizeResult(tokens, errors) { |
| this.tokens = tokens; |
| this.errors = errors; |
| } |
| return TokenizeResult; |
| }()); |
| function tokenize(source, url, getTagDefinition, options) { |
| if (options === void 0) { options = {}; } |
| return new _Tokenizer(new ParseSourceFile(source, url), getTagDefinition, options).tokenize(); |
| } |
| var _CR_OR_CRLF_REGEXP = /\r\n?/g; |
| function _unexpectedCharacterErrorMsg(charCode) { |
| var char = charCode === $EOF ? 'EOF' : String.fromCharCode(charCode); |
| return "Unexpected character \"" + char + "\""; |
| } |
| function _unknownEntityErrorMsg(entitySrc) { |
| return "Unknown entity \"" + entitySrc + "\" - use the \"&#<decimal>;\" or \"&#x<hex>;\" syntax"; |
| } |
| var _ControlFlowError = /** @class */ (function () { |
| function _ControlFlowError(error) { |
| this.error = error; |
| } |
| return _ControlFlowError; |
| }()); |
| // See http://www.w3.org/TR/html51/syntax.html#writing |
| var _Tokenizer = /** @class */ (function () { |
| /** |
| * @param _file The html source file being tokenized. |
| * @param _getTagDefinition A function that will retrieve a tag definition for a given tag name. |
| * @param options Configuration of the tokenization. |
| */ |
| function _Tokenizer(_file, _getTagDefinition, options) { |
| this._getTagDefinition = _getTagDefinition; |
| this._currentTokenStart = null; |
| this._currentTokenType = null; |
| this._expansionCaseStack = []; |
| this._inInterpolation = false; |
| this.tokens = []; |
| this.errors = []; |
| this._tokenizeIcu = options.tokenizeExpansionForms || false; |
| this._interpolationConfig = options.interpolationConfig || DEFAULT_INTERPOLATION_CONFIG; |
| this._leadingTriviaCodePoints = |
| options.leadingTriviaChars && options.leadingTriviaChars.map(function (c) { return c.codePointAt(0) || 0; }); |
| var range = options.range || { endPos: _file.content.length, startPos: 0, startLine: 0, startCol: 0 }; |
| this._cursor = options.escapedString ? new EscapedCharacterCursor(_file, range) : |
| new PlainCharacterCursor(_file, range); |
| try { |
| this._cursor.init(); |
| } |
| catch (e) { |
| this.handleError(e); |
| } |
| } |
| _Tokenizer.prototype._processCarriageReturns = function (content) { |
| // http://www.w3.org/TR/html5/syntax.html#preprocessing-the-input-stream |
| // In order to keep the original position in the source, we can not |
| // pre-process it. |
| // Instead CRs are processed right before instantiating the tokens. |
| return content.replace(_CR_OR_CRLF_REGEXP, '\n'); |
| }; |
| _Tokenizer.prototype.tokenize = function () { |
| while (this._cursor.peek() !== $EOF) { |
| var start = this._cursor.clone(); |
| try { |
| if (this._attemptCharCode($LT)) { |
| if (this._attemptCharCode($BANG)) { |
| if (this._attemptCharCode($LBRACKET)) { |
| this._consumeCdata(start); |
| } |
| else if (this._attemptCharCode($MINUS)) { |
| this._consumeComment(start); |
| } |
| else { |
| this._consumeDocType(start); |
| } |
| } |
| else if (this._attemptCharCode($SLASH)) { |
| this._consumeTagClose(start); |
| } |
| else { |
| this._consumeTagOpen(start); |
| } |
| } |
| else if (!(this._tokenizeIcu && this._tokenizeExpansionForm())) { |
| this._consumeText(); |
| } |
| } |
| catch (e) { |
| this.handleError(e); |
| } |
| } |
| this._beginToken(TokenType.EOF); |
| this._endToken([]); |
| return new TokenizeResult(mergeTextTokens(this.tokens), this.errors); |
| }; |
| /** |
| * @returns whether an ICU token has been created |
| * @internal |
| */ |
| _Tokenizer.prototype._tokenizeExpansionForm = function () { |
| if (this.isExpansionFormStart()) { |
| this._consumeExpansionFormStart(); |
| return true; |
| } |
| if (isExpansionCaseStart(this._cursor.peek()) && this._isInExpansionForm()) { |
| this._consumeExpansionCaseStart(); |
| return true; |
| } |
| if (this._cursor.peek() === $RBRACE) { |
| if (this._isInExpansionCase()) { |
| this._consumeExpansionCaseEnd(); |
| return true; |
| } |
| if (this._isInExpansionForm()) { |
| this._consumeExpansionFormEnd(); |
| return true; |
| } |
| } |
| return false; |
| }; |
| _Tokenizer.prototype._beginToken = function (type, start) { |
| if (start === void 0) { start = this._cursor.clone(); } |
| this._currentTokenStart = start; |
| this._currentTokenType = type; |
| }; |
| _Tokenizer.prototype._endToken = function (parts, end) { |
| if (end === void 0) { end = this._cursor.clone(); } |
| if (this._currentTokenStart === null) { |
| throw new TokenError('Programming error - attempted to end a token when there was no start to the token', this._currentTokenType, this._cursor.getSpan(end)); |
| } |
| if (this._currentTokenType === null) { |
| throw new TokenError('Programming error - attempted to end a token which has no token type', null, this._cursor.getSpan(this._currentTokenStart)); |
| } |
| var token = new Token(this._currentTokenType, parts, this._cursor.getSpan(this._currentTokenStart, this._leadingTriviaCodePoints)); |
| this.tokens.push(token); |
| this._currentTokenStart = null; |
| this._currentTokenType = null; |
| return token; |
| }; |
| _Tokenizer.prototype._createError = function (msg, span) { |
| if (this._isInExpansionForm()) { |
| msg += " (Do you have an unescaped \"{\" in your template? Use \"{{ '{' }}\") to escape it.)"; |
| } |
| var error = new TokenError(msg, this._currentTokenType, span); |
| this._currentTokenStart = null; |
| this._currentTokenType = null; |
| return new _ControlFlowError(error); |
| }; |
| _Tokenizer.prototype.handleError = function (e) { |
| if (e instanceof CursorError) { |
| e = this._createError(e.msg, this._cursor.getSpan(e.cursor)); |
| } |
| if (e instanceof _ControlFlowError) { |
| this.errors.push(e.error); |
| } |
| else { |
| throw e; |
| } |
| }; |
| _Tokenizer.prototype._attemptCharCode = function (charCode) { |
| if (this._cursor.peek() === charCode) { |
| this._cursor.advance(); |
| return true; |
| } |
| return false; |
| }; |
| _Tokenizer.prototype._attemptCharCodeCaseInsensitive = function (charCode) { |
| if (compareCharCodeCaseInsensitive(this._cursor.peek(), charCode)) { |
| this._cursor.advance(); |
| return true; |
| } |
| return false; |
| }; |
| _Tokenizer.prototype._requireCharCode = function (charCode) { |
| var location = this._cursor.clone(); |
| if (!this._attemptCharCode(charCode)) { |
| throw this._createError(_unexpectedCharacterErrorMsg(this._cursor.peek()), this._cursor.getSpan(location)); |
| } |
| }; |
| _Tokenizer.prototype._attemptStr = function (chars) { |
| var len = chars.length; |
| if (this._cursor.charsLeft() < len) { |
| return false; |
| } |
| var initialPosition = this._cursor.clone(); |
| for (var i = 0; i < len; i++) { |
| if (!this._attemptCharCode(chars.charCodeAt(i))) { |
| // If attempting to parse the string fails, we want to reset the parser |
| // to where it was before the attempt |
| this._cursor = initialPosition; |
| return false; |
| } |
| } |
| return true; |
| }; |
| _Tokenizer.prototype._attemptStrCaseInsensitive = function (chars) { |
| for (var i = 0; i < chars.length; i++) { |
| if (!this._attemptCharCodeCaseInsensitive(chars.charCodeAt(i))) { |
| return false; |
| } |
| } |
| return true; |
| }; |
| _Tokenizer.prototype._requireStr = function (chars) { |
| var location = this._cursor.clone(); |
| if (!this._attemptStr(chars)) { |
| throw this._createError(_unexpectedCharacterErrorMsg(this._cursor.peek()), this._cursor.getSpan(location)); |
| } |
| }; |
| _Tokenizer.prototype._attemptCharCodeUntilFn = function (predicate) { |
| while (!predicate(this._cursor.peek())) { |
| this._cursor.advance(); |
| } |
| }; |
| _Tokenizer.prototype._requireCharCodeUntilFn = function (predicate, len) { |
| var start = this._cursor.clone(); |
| this._attemptCharCodeUntilFn(predicate); |
| var end = this._cursor.clone(); |
| if (end.diff(start) < len) { |
| throw this._createError(_unexpectedCharacterErrorMsg(this._cursor.peek()), this._cursor.getSpan(start)); |
| } |
| }; |
| _Tokenizer.prototype._attemptUntilChar = function (char) { |
| while (this._cursor.peek() !== char) { |
| this._cursor.advance(); |
| } |
| }; |
| _Tokenizer.prototype._readChar = function (decodeEntities) { |
| if (decodeEntities && this._cursor.peek() === $AMPERSAND) { |
| return this._decodeEntity(); |
| } |
| else { |
| // Don't rely upon reading directly from `_input` as the actual char value |
| // may have been generated from an escape sequence. |
| var char = String.fromCodePoint(this._cursor.peek()); |
| this._cursor.advance(); |
| return char; |
| } |
| }; |
| _Tokenizer.prototype._decodeEntity = function () { |
| var start = this._cursor.clone(); |
| this._cursor.advance(); |
| if (this._attemptCharCode($HASH)) { |
| var isHex = this._attemptCharCode($x) || this._attemptCharCode($X); |
| var codeStart = this._cursor.clone(); |
| this._attemptCharCodeUntilFn(isDigitEntityEnd); |
| if (this._cursor.peek() != $SEMICOLON) { |
| throw this._createError(_unexpectedCharacterErrorMsg(this._cursor.peek()), this._cursor.getSpan()); |
| } |
| var strNum = this._cursor.getChars(codeStart); |
| this._cursor.advance(); |
| try { |
| var charCode = parseInt(strNum, isHex ? 16 : 10); |
| return String.fromCharCode(charCode); |
| } |
| catch (_a) { |
| throw this._createError(_unknownEntityErrorMsg(this._cursor.getChars(start)), this._cursor.getSpan()); |
| } |
| } |
| else { |
| var nameStart = this._cursor.clone(); |
| this._attemptCharCodeUntilFn(isNamedEntityEnd); |
| if (this._cursor.peek() != $SEMICOLON) { |
| this._cursor = nameStart; |
| return '&'; |
| } |
| var name_1 = this._cursor.getChars(nameStart); |
| this._cursor.advance(); |
| var char = NAMED_ENTITIES[name_1]; |
| if (!char) { |
| throw this._createError(_unknownEntityErrorMsg(name_1), this._cursor.getSpan(start)); |
| } |
| return char; |
| } |
| }; |
| _Tokenizer.prototype._consumeRawText = function (decodeEntities, endMarkerPredicate) { |
| this._beginToken(decodeEntities ? TokenType.ESCAPABLE_RAW_TEXT : TokenType.RAW_TEXT); |
| var parts = []; |
| while (true) { |
| var tagCloseStart = this._cursor.clone(); |
| var foundEndMarker = endMarkerPredicate(); |
| this._cursor = tagCloseStart; |
| if (foundEndMarker) { |
| break; |
| } |
| parts.push(this._readChar(decodeEntities)); |
| } |
| return this._endToken([this._processCarriageReturns(parts.join(''))]); |
| }; |
| _Tokenizer.prototype._consumeComment = function (start) { |
| var _this = this; |
| this._beginToken(TokenType.COMMENT_START, start); |
| this._requireCharCode($MINUS); |
| this._endToken([]); |
| this._consumeRawText(false, function () { return _this._attemptStr('-->'); }); |
| this._beginToken(TokenType.COMMENT_END); |
| this._requireStr('-->'); |
| this._endToken([]); |
| }; |
| _Tokenizer.prototype._consumeCdata = function (start) { |
| var _this = this; |
| this._beginToken(TokenType.CDATA_START, start); |
| this._requireStr('CDATA['); |
| this._endToken([]); |
| this._consumeRawText(false, function () { return _this._attemptStr(']]>'); }); |
| this._beginToken(TokenType.CDATA_END); |
| this._requireStr(']]>'); |
| this._endToken([]); |
| }; |
| _Tokenizer.prototype._consumeDocType = function (start) { |
| this._beginToken(TokenType.DOC_TYPE, start); |
| var contentStart = this._cursor.clone(); |
| this._attemptUntilChar($GT); |
| var content = this._cursor.getChars(contentStart); |
| this._cursor.advance(); |
| this._endToken([content]); |
| }; |
| _Tokenizer.prototype._consumePrefixAndName = function () { |
| var nameOrPrefixStart = this._cursor.clone(); |
| var prefix = ''; |
| while (this._cursor.peek() !== $COLON && !isPrefixEnd(this._cursor.peek())) { |
| this._cursor.advance(); |
| } |
| var nameStart; |
| if (this._cursor.peek() === $COLON) { |
| prefix = this._cursor.getChars(nameOrPrefixStart); |
| this._cursor.advance(); |
| nameStart = this._cursor.clone(); |
| } |
| else { |
| nameStart = nameOrPrefixStart; |
| } |
| this._requireCharCodeUntilFn(isNameEnd, prefix === '' ? 0 : 1); |
| var name = this._cursor.getChars(nameStart); |
| return [prefix, name]; |
| }; |
| _Tokenizer.prototype._consumeTagOpen = function (start) { |
| var tagName; |
| var prefix; |
| var openTagToken; |
| var tokensBeforeTagOpen = this.tokens.length; |
| var innerStart = this._cursor.clone(); |
| try { |
| if (!isAsciiLetter(this._cursor.peek())) { |
| throw this._createError(_unexpectedCharacterErrorMsg(this._cursor.peek()), this._cursor.getSpan(start)); |
| } |
| openTagToken = this._consumeTagOpenStart(start); |
| prefix = openTagToken.parts[0]; |
| tagName = openTagToken.parts[1]; |
| this._attemptCharCodeUntilFn(isNotWhitespace); |
| while (this._cursor.peek() !== $SLASH && this._cursor.peek() !== $GT) { |
| this._consumeAttributeName(); |
| this._attemptCharCodeUntilFn(isNotWhitespace); |
| if (this._attemptCharCode($EQ)) { |
| this._attemptCharCodeUntilFn(isNotWhitespace); |
| this._consumeAttributeValue(); |
| } |
| this._attemptCharCodeUntilFn(isNotWhitespace); |
| } |
| this._consumeTagOpenEnd(); |
| } |
| catch (e) { |
| if (e instanceof _ControlFlowError) { |
| // When the start tag is invalid (including invalid "attributes"), assume we want a "<" |
| this._cursor = innerStart; |
| if (openTagToken) { |
| this.tokens.length = tokensBeforeTagOpen; |
| } |
| // Back to back text tokens are merged at the end |
| this._beginToken(TokenType.TEXT, start); |
| this._endToken(['<']); |
| return; |
| } |
| throw e; |
| } |
| var contentTokenType = this._getTagDefinition(tagName).contentType; |
| if (contentTokenType === exports.TagContentType.RAW_TEXT) { |
| this._consumeRawTextWithTagClose(prefix, tagName, false); |
| } |
| else if (contentTokenType === exports.TagContentType.ESCAPABLE_RAW_TEXT) { |
| this._consumeRawTextWithTagClose(prefix, tagName, true); |
| } |
| }; |
| _Tokenizer.prototype._consumeRawTextWithTagClose = function (prefix, tagName, decodeEntities) { |
| var _this = this; |
| var textToken = this._consumeRawText(decodeEntities, function () { |
| if (!_this._attemptCharCode($LT)) |
| return false; |
| if (!_this._attemptCharCode($SLASH)) |
| return false; |
| _this._attemptCharCodeUntilFn(isNotWhitespace); |
| if (!_this._attemptStrCaseInsensitive(tagName)) |
| return false; |
| _this._attemptCharCodeUntilFn(isNotWhitespace); |
| return _this._attemptCharCode($GT); |
| }); |
| this._beginToken(TokenType.TAG_CLOSE); |
| this._requireCharCodeUntilFn(function (code) { return code === $GT; }, 3); |
| this._cursor.advance(); // Consume the `>` |
| this._endToken([prefix, tagName]); |
| }; |
| _Tokenizer.prototype._consumeTagOpenStart = function (start) { |
| this._beginToken(TokenType.TAG_OPEN_START, start); |
| var parts = this._consumePrefixAndName(); |
| return this._endToken(parts); |
| }; |
| _Tokenizer.prototype._consumeAttributeName = function () { |
| var attrNameStart = this._cursor.peek(); |
| if (attrNameStart === $SQ || attrNameStart === $DQ) { |
| throw this._createError(_unexpectedCharacterErrorMsg(attrNameStart), this._cursor.getSpan()); |
| } |
| this._beginToken(TokenType.ATTR_NAME); |
| var prefixAndName = this._consumePrefixAndName(); |
| this._endToken(prefixAndName); |
| }; |
| _Tokenizer.prototype._consumeAttributeValue = function () { |
| var value; |
| if (this._cursor.peek() === $SQ || this._cursor.peek() === $DQ) { |
| this._beginToken(TokenType.ATTR_QUOTE); |
| var quoteChar = this._cursor.peek(); |
| this._cursor.advance(); |
| this._endToken([String.fromCodePoint(quoteChar)]); |
| this._beginToken(TokenType.ATTR_VALUE); |
| var parts = []; |
| while (this._cursor.peek() !== quoteChar) { |
| parts.push(this._readChar(true)); |
| } |
| value = parts.join(''); |
| this._endToken([this._processCarriageReturns(value)]); |
| this._beginToken(TokenType.ATTR_QUOTE); |
| this._cursor.advance(); |
| this._endToken([String.fromCodePoint(quoteChar)]); |
| } |
| else { |
| this._beginToken(TokenType.ATTR_VALUE); |
| var valueStart = this._cursor.clone(); |
| this._requireCharCodeUntilFn(isNameEnd, 1); |
| value = this._cursor.getChars(valueStart); |
| this._endToken([this._processCarriageReturns(value)]); |
| } |
| }; |
| _Tokenizer.prototype._consumeTagOpenEnd = function () { |
| var tokenType = this._attemptCharCode($SLASH) ? TokenType.TAG_OPEN_END_VOID : TokenType.TAG_OPEN_END; |
| this._beginToken(tokenType); |
| this._requireCharCode($GT); |
| this._endToken([]); |
| }; |
| _Tokenizer.prototype._consumeTagClose = function (start) { |
| this._beginToken(TokenType.TAG_CLOSE, start); |
| this._attemptCharCodeUntilFn(isNotWhitespace); |
| var prefixAndName = this._consumePrefixAndName(); |
| this._attemptCharCodeUntilFn(isNotWhitespace); |
| this._requireCharCode($GT); |
| this._endToken(prefixAndName); |
| }; |
| _Tokenizer.prototype._consumeExpansionFormStart = function () { |
| this._beginToken(TokenType.EXPANSION_FORM_START); |
| this._requireCharCode($LBRACE); |
| this._endToken([]); |
| this._expansionCaseStack.push(TokenType.EXPANSION_FORM_START); |
| this._beginToken(TokenType.RAW_TEXT); |
| var condition = this._readUntil($COMMA); |
| this._endToken([condition]); |
| this._requireCharCode($COMMA); |
| this._attemptCharCodeUntilFn(isNotWhitespace); |
| this._beginToken(TokenType.RAW_TEXT); |
| var type = this._readUntil($COMMA); |
| this._endToken([type]); |
| this._requireCharCode($COMMA); |
| this._attemptCharCodeUntilFn(isNotWhitespace); |
| }; |
| _Tokenizer.prototype._consumeExpansionCaseStart = function () { |
| this._beginToken(TokenType.EXPANSION_CASE_VALUE); |
| var value = this._readUntil($LBRACE).trim(); |
| this._endToken([value]); |
| this._attemptCharCodeUntilFn(isNotWhitespace); |
| this._beginToken(TokenType.EXPANSION_CASE_EXP_START); |
| this._requireCharCode($LBRACE); |
| this._endToken([]); |
| this._attemptCharCodeUntilFn(isNotWhitespace); |
| this._expansionCaseStack.push(TokenType.EXPANSION_CASE_EXP_START); |
| }; |
| _Tokenizer.prototype._consumeExpansionCaseEnd = function () { |
| this._beginToken(TokenType.EXPANSION_CASE_EXP_END); |
| this._requireCharCode($RBRACE); |
| this._endToken([]); |
| this._attemptCharCodeUntilFn(isNotWhitespace); |
| this._expansionCaseStack.pop(); |
| }; |
| _Tokenizer.prototype._consumeExpansionFormEnd = function () { |
| this._beginToken(TokenType.EXPANSION_FORM_END); |
| this._requireCharCode($RBRACE); |
| this._endToken([]); |
| this._expansionCaseStack.pop(); |
| }; |
| _Tokenizer.prototype._consumeText = function () { |
| var start = this._cursor.clone(); |
| this._beginToken(TokenType.TEXT, start); |
| var parts = []; |
| do { |
| if (this._interpolationConfig && this._attemptStr(this._interpolationConfig.start)) { |
| parts.push(this._interpolationConfig.start); |
| this._inInterpolation = true; |
| } |
| else if (this._interpolationConfig && this._inInterpolation && |
| this._attemptStr(this._interpolationConfig.end)) { |
| parts.push(this._interpolationConfig.end); |
| this._inInterpolation = false; |
| } |
| else { |
| parts.push(this._readChar(true)); |
| } |
| } while (!this._isTextEnd()); |
| this._endToken([this._processCarriageReturns(parts.join(''))]); |
| }; |
| _Tokenizer.prototype._isTextEnd = function () { |
| if (this._cursor.peek() === $LT || this._cursor.peek() === $EOF) { |
| return true; |
| } |
| if (this._tokenizeIcu && !this._inInterpolation) { |
| if (this.isExpansionFormStart()) { |
| // start of an expansion form |
| return true; |
| } |
| if (this._cursor.peek() === $RBRACE && this._isInExpansionCase()) { |
| // end of and expansion case |
| return true; |
| } |
| } |
| return false; |
| }; |
| _Tokenizer.prototype._readUntil = function (char) { |
| var start = this._cursor.clone(); |
| this._attemptUntilChar(char); |
| return this._cursor.getChars(start); |
| }; |
| _Tokenizer.prototype._isInExpansionCase = function () { |
| return this._expansionCaseStack.length > 0 && |
| this._expansionCaseStack[this._expansionCaseStack.length - 1] === |
| TokenType.EXPANSION_CASE_EXP_START; |
| }; |
| _Tokenizer.prototype._isInExpansionForm = function () { |
| return this._expansionCaseStack.length > 0 && |
| this._expansionCaseStack[this._expansionCaseStack.length - 1] === |
| TokenType.EXPANSION_FORM_START; |
| }; |
| _Tokenizer.prototype.isExpansionFormStart = function () { |
| if (this._cursor.peek() !== $LBRACE) { |
| return false; |
| } |
| if (this._interpolationConfig) { |
| var start = this._cursor.clone(); |
| var isInterpolation = this._attemptStr(this._interpolationConfig.start); |
| this._cursor = start; |
| return !isInterpolation; |
| } |
| return true; |
| }; |
| return _Tokenizer; |
| }()); |
| function isNotWhitespace(code) { |
| return !isWhitespace(code) || code === $EOF; |
| } |
| function isNameEnd(code) { |
| return isWhitespace(code) || code === $GT || code === $SLASH || |
| code === $SQ || code === $DQ || code === $EQ; |
| } |
| function isPrefixEnd(code) { |
| return (code < $a || $z < code) && (code < $A || $Z < code) && |
| (code < $0 || code > $9); |
| } |
| function isDigitEntityEnd(code) { |
| return code == $SEMICOLON || code == $EOF || !isAsciiHexDigit(code); |
| } |
| function isNamedEntityEnd(code) { |
| return code == $SEMICOLON || code == $EOF || !isAsciiLetter(code); |
| } |
| function isExpansionCaseStart(peek) { |
| return peek === $EQ || isAsciiLetter(peek) || isDigit(peek); |
| } |
| function compareCharCodeCaseInsensitive(code1, code2) { |
| return toUpperCaseCharCode(code1) == toUpperCaseCharCode(code2); |
| } |
| function toUpperCaseCharCode(code) { |
| return code >= $a && code <= $z ? code - $a + $A : code; |
| } |
| function mergeTextTokens(srcTokens) { |
| var dstTokens = []; |
| var lastDstToken = undefined; |
| for (var i = 0; i < srcTokens.length; i++) { |
| var token = srcTokens[i]; |
| if (lastDstToken && lastDstToken.type == TokenType.TEXT && token.type == TokenType.TEXT) { |
| lastDstToken.parts[0] += token.parts[0]; |
| lastDstToken.sourceSpan.end = token.sourceSpan.end; |
| } |
| else { |
| lastDstToken = token; |
| dstTokens.push(lastDstToken); |
| } |
| } |
| return dstTokens; |
| } |
| var PlainCharacterCursor = /** @class */ (function () { |
| function PlainCharacterCursor(fileOrCursor, range) { |
| if (fileOrCursor instanceof PlainCharacterCursor) { |
| this.file = fileOrCursor.file; |
| this.input = fileOrCursor.input; |
| this.end = fileOrCursor.end; |
| this.state = __assign({}, fileOrCursor.state); |
| } |
| else { |
| if (!range) { |
| throw new Error('Programming error: the range argument must be provided with a file argument.'); |
| } |
| this.file = fileOrCursor; |
| this.input = fileOrCursor.content; |
| this.end = range.endPos; |
| this.state = { |
| peek: -1, |
| offset: range.startPos, |
| line: range.startLine, |
| column: range.startCol, |
| }; |
| } |
| } |
| PlainCharacterCursor.prototype.clone = function () { return new PlainCharacterCursor(this); }; |
| PlainCharacterCursor.prototype.peek = function () { return this.state.peek; }; |
| PlainCharacterCursor.prototype.charsLeft = function () { return this.end - this.state.offset; }; |
| PlainCharacterCursor.prototype.diff = function (other) { return this.state.offset - other.state.offset; }; |
| PlainCharacterCursor.prototype.advance = function () { this.advanceState(this.state); }; |
| PlainCharacterCursor.prototype.init = function () { this.updatePeek(this.state); }; |
| PlainCharacterCursor.prototype.getSpan = function (start, leadingTriviaCodePoints) { |
| start = start || this; |
| if (leadingTriviaCodePoints) { |
| start = start.clone(); |
| while (this.diff(start) > 0 && leadingTriviaCodePoints.indexOf(start.peek()) !== -1) { |
| start.advance(); |
| } |
| } |
| return new ParseSourceSpan(new ParseLocation(start.file, start.state.offset, start.state.line, start.state.column), new ParseLocation(this.file, this.state.offset, this.state.line, this.state.column)); |
| }; |
| PlainCharacterCursor.prototype.getChars = function (start) { |
| return this.input.substring(start.state.offset, this.state.offset); |
| }; |
| PlainCharacterCursor.prototype.charAt = function (pos) { return this.input.charCodeAt(pos); }; |
| PlainCharacterCursor.prototype.advanceState = function (state) { |
| if (state.offset >= this.end) { |
| this.state = state; |
| throw new CursorError('Unexpected character "EOF"', this); |
| } |
| var currentChar = this.charAt(state.offset); |
| if (currentChar === $LF) { |
| state.line++; |
| state.column = 0; |
| } |
| else if (!isNewLine(currentChar)) { |
| state.column++; |
| } |
| state.offset++; |
| this.updatePeek(state); |
| }; |
| PlainCharacterCursor.prototype.updatePeek = function (state) { |
| state.peek = state.offset >= this.end ? $EOF : this.charAt(state.offset); |
| }; |
| return PlainCharacterCursor; |
| }()); |
| var EscapedCharacterCursor = /** @class */ (function (_super) { |
| __extends(EscapedCharacterCursor, _super); |
| function EscapedCharacterCursor(fileOrCursor, range) { |
| var _this = this; |
| if (fileOrCursor instanceof EscapedCharacterCursor) { |
| _this = _super.call(this, fileOrCursor) || this; |
| _this.internalState = __assign({}, fileOrCursor.internalState); |
| } |
| else { |
| _this = _super.call(this, fileOrCursor, range) || this; |
| _this.internalState = _this.state; |
| } |
| return _this; |
| } |
| EscapedCharacterCursor.prototype.advance = function () { |
| this.state = this.internalState; |
| _super.prototype.advance.call(this); |
| this.processEscapeSequence(); |
| }; |
| EscapedCharacterCursor.prototype.init = function () { |
| _super.prototype.init.call(this); |
| this.processEscapeSequence(); |
| }; |
| EscapedCharacterCursor.prototype.clone = function () { return new EscapedCharacterCursor(this); }; |
| EscapedCharacterCursor.prototype.getChars = function (start) { |
| var cursor = start.clone(); |
| var chars = ''; |
| while (cursor.internalState.offset < this.internalState.offset) { |
| chars += String.fromCodePoint(cursor.peek()); |
| cursor.advance(); |
| } |
| return chars; |
| }; |
| /** |
| * Process the escape sequence that starts at the current position in the text. |
| * |
| * This method is called to ensure that `peek` has the unescaped value of escape sequences. |
| */ |
| EscapedCharacterCursor.prototype.processEscapeSequence = function () { |
| var _this = this; |
| var peek = function () { return _this.internalState.peek; }; |
| if (peek() === $BACKSLASH) { |
| // We have hit an escape sequence so we need the internal state to become independent |
| // of the external state. |
| this.internalState = __assign({}, this.state); |
| // Move past the backslash |
| this.advanceState(this.internalState); |
| // First check for standard control char sequences |
| if (peek() === $n) { |
| this.state.peek = $LF; |
| } |
| else if (peek() === $r) { |
| this.state.peek = $CR; |
| } |
| else if (peek() === $v) { |
| this.state.peek = $VTAB; |
| } |
| else if (peek() === $t) { |
| this.state.peek = $TAB; |
| } |
| else if (peek() === $b) { |
| this.state.peek = $BSPACE; |
| } |
| else if (peek() === $f) { |
| this.state.peek = $FF; |
| } |
| // Now consider more complex sequences |
| else if (peek() === $u) { |
| // Unicode code-point sequence |
| this.advanceState(this.internalState); // advance past the `u` char |
| if (peek() === $LBRACE) { |
| // Variable length Unicode, e.g. `\x{123}` |
| this.advanceState(this.internalState); // advance past the `{` char |
| // Advance past the variable number of hex digits until we hit a `}` char |
| var digitStart = this.clone(); |
| var length_1 = 0; |
| while (peek() !== $RBRACE) { |
| this.advanceState(this.internalState); |
| length_1++; |
| } |
| this.state.peek = this.decodeHexDigits(digitStart, length_1); |
| } |
| else { |
| // Fixed length Unicode, e.g. `\u1234` |
| var digitStart = this.clone(); |
| this.advanceState(this.internalState); |
| this.advanceState(this.internalState); |
| this.advanceState(this.internalState); |
| this.state.peek = this.decodeHexDigits(digitStart, 4); |
| } |
| } |
| else if (peek() === $x) { |
| // Hex char code, e.g. `\x2F` |
| this.advanceState(this.internalState); // advance past the `x` char |
| var digitStart = this.clone(); |
| this.advanceState(this.internalState); |
| this.state.peek = this.decodeHexDigits(digitStart, 2); |
| } |
| else if (isOctalDigit(peek())) { |
| // Octal char code, e.g. `\012`, |
| var octal = ''; |
| var length_2 = 0; |
| var previous = this.clone(); |
| while (isOctalDigit(peek()) && length_2 < 3) { |
| previous = this.clone(); |
| octal += String.fromCodePoint(peek()); |
| this.advanceState(this.internalState); |
| length_2++; |
| } |
| this.state.peek = parseInt(octal, 8); |
| // Backup one char |
| this.internalState = previous.internalState; |
| } |
| else if (isNewLine(this.internalState.peek)) { |
| // Line continuation `\` followed by a new line |
| this.advanceState(this.internalState); // advance over the newline |
| this.state = this.internalState; |
| } |
| else { |
| // If none of the `if` blocks were executed then we just have an escaped normal character. |
| // In that case we just, effectively, skip the backslash from the character. |
| this.state.peek = this.internalState.peek; |
| } |
| } |
| }; |
| EscapedCharacterCursor.prototype.decodeHexDigits = function (start, length) { |
| var hex = this.input.substr(start.internalState.offset, length); |
| var charCode = parseInt(hex, 16); |
| if (!isNaN(charCode)) { |
| return charCode; |
| } |
| else { |
| start.state = start.internalState; |
| throw new CursorError('Invalid hexadecimal escape sequence', start); |
| } |
| }; |
| return EscapedCharacterCursor; |
| }(PlainCharacterCursor)); |
| var CursorError = /** @class */ (function () { |
| function CursorError(msg, cursor) { |
| this.msg = msg; |
| this.cursor = cursor; |
| } |
| return CursorError; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var TreeError = /** @class */ (function (_super) { |
| __extends(TreeError, _super); |
| function TreeError(elementName, span, msg) { |
| var _this = _super.call(this, span, msg) || this; |
| _this.elementName = elementName; |
| return _this; |
| } |
| TreeError.create = function (elementName, span, msg) { |
| return new TreeError(elementName, span, msg); |
| }; |
| return TreeError; |
| }(ParseError)); |
| var ParseTreeResult = /** @class */ (function () { |
| function ParseTreeResult(rootNodes, errors) { |
| this.rootNodes = rootNodes; |
| this.errors = errors; |
| } |
| return ParseTreeResult; |
| }()); |
| var Parser = /** @class */ (function () { |
| function Parser(getTagDefinition) { |
| this.getTagDefinition = getTagDefinition; |
| } |
| Parser.prototype.parse = function (source, url, options) { |
| var tokensAndErrors = tokenize(source, url, this.getTagDefinition, options); |
| var treeAndErrors = new _TreeBuilder(tokensAndErrors.tokens, this.getTagDefinition).build(); |
| return new ParseTreeResult(treeAndErrors.rootNodes, tokensAndErrors.errors.concat(treeAndErrors.errors)); |
| }; |
| return Parser; |
| }()); |
| var _TreeBuilder = /** @class */ (function () { |
| function _TreeBuilder(tokens, getTagDefinition) { |
| this.tokens = tokens; |
| this.getTagDefinition = getTagDefinition; |
| this._index = -1; |
| this._rootNodes = []; |
| this._errors = []; |
| this._elementStack = []; |
| this._advance(); |
| } |
| _TreeBuilder.prototype.build = function () { |
| while (this._peek.type !== TokenType.EOF) { |
| if (this._peek.type === TokenType.TAG_OPEN_START) { |
| this._consumeStartTag(this._advance()); |
| } |
| else if (this._peek.type === TokenType.TAG_CLOSE) { |
| this._consumeEndTag(this._advance()); |
| } |
| else if (this._peek.type === TokenType.CDATA_START) { |
| this._closeVoidElement(); |
| this._consumeCdata(this._advance()); |
| } |
| else if (this._peek.type === TokenType.COMMENT_START) { |
| this._closeVoidElement(); |
| this._consumeComment(this._advance()); |
| } |
| else if (this._peek.type === TokenType.TEXT || this._peek.type === TokenType.RAW_TEXT || |
| this._peek.type === TokenType.ESCAPABLE_RAW_TEXT) { |
| this._closeVoidElement(); |
| this._consumeText(this._advance()); |
| } |
| else if (this._peek.type === TokenType.EXPANSION_FORM_START) { |
| this._consumeExpansion(this._advance()); |
| } |
| else { |
| // Skip all other tokens... |
| this._advance(); |
| } |
| } |
| return new ParseTreeResult(this._rootNodes, this._errors); |
| }; |
| _TreeBuilder.prototype._advance = function () { |
| var prev = this._peek; |
| if (this._index < this.tokens.length - 1) { |
| // Note: there is always an EOF token at the end |
| this._index++; |
| } |
| this._peek = this.tokens[this._index]; |
| return prev; |
| }; |
| _TreeBuilder.prototype._advanceIf = function (type) { |
| if (this._peek.type === type) { |
| return this._advance(); |
| } |
| return null; |
| }; |
| _TreeBuilder.prototype._consumeCdata = function (startToken) { |
| this._consumeText(this._advance()); |
| this._advanceIf(TokenType.CDATA_END); |
| }; |
| _TreeBuilder.prototype._consumeComment = function (token) { |
| var text = this._advanceIf(TokenType.RAW_TEXT); |
| this._advanceIf(TokenType.COMMENT_END); |
| var value = text != null ? text.parts[0].trim() : null; |
| this._addToParent(new Comment(value, token.sourceSpan)); |
| }; |
| _TreeBuilder.prototype._consumeExpansion = function (token) { |
| var switchValue = this._advance(); |
| var type = this._advance(); |
| var cases = []; |
| // read = |
| while (this._peek.type === TokenType.EXPANSION_CASE_VALUE) { |
| var expCase = this._parseExpansionCase(); |
| if (!expCase) |
| return; // error |
| cases.push(expCase); |
| } |
| // read the final } |
| if (this._peek.type !== TokenType.EXPANSION_FORM_END) { |
| this._errors.push(TreeError.create(null, this._peek.sourceSpan, "Invalid ICU message. Missing '}'.")); |
| return; |
| } |
| var sourceSpan = new ParseSourceSpan(token.sourceSpan.start, this._peek.sourceSpan.end); |
| this._addToParent(new Expansion(switchValue.parts[0], type.parts[0], cases, sourceSpan, switchValue.sourceSpan)); |
| this._advance(); |
| }; |
| _TreeBuilder.prototype._parseExpansionCase = function () { |
| var value = this._advance(); |
| // read { |
| if (this._peek.type !== TokenType.EXPANSION_CASE_EXP_START) { |
| this._errors.push(TreeError.create(null, this._peek.sourceSpan, "Invalid ICU message. Missing '{'.")); |
| return null; |
| } |
| // read until } |
| var start = this._advance(); |
| var exp = this._collectExpansionExpTokens(start); |
| if (!exp) |
| return null; |
| var end = this._advance(); |
| exp.push(new Token(TokenType.EOF, [], end.sourceSpan)); |
| // parse everything in between { and } |
| var parsedExp = new _TreeBuilder(exp, this.getTagDefinition).build(); |
| if (parsedExp.errors.length > 0) { |
| this._errors = this._errors.concat(parsedExp.errors); |
| return null; |
| } |
| var sourceSpan = new ParseSourceSpan(value.sourceSpan.start, end.sourceSpan.end); |
| var expSourceSpan = new ParseSourceSpan(start.sourceSpan.start, end.sourceSpan.end); |
| return new ExpansionCase(value.parts[0], parsedExp.rootNodes, sourceSpan, value.sourceSpan, expSourceSpan); |
| }; |
| _TreeBuilder.prototype._collectExpansionExpTokens = function (start) { |
| var exp = []; |
| var expansionFormStack = [TokenType.EXPANSION_CASE_EXP_START]; |
| while (true) { |
| if (this._peek.type === TokenType.EXPANSION_FORM_START || |
| this._peek.type === TokenType.EXPANSION_CASE_EXP_START) { |
| expansionFormStack.push(this._peek.type); |
| } |
| if (this._peek.type === TokenType.EXPANSION_CASE_EXP_END) { |
| if (lastOnStack(expansionFormStack, TokenType.EXPANSION_CASE_EXP_START)) { |
| expansionFormStack.pop(); |
| if (expansionFormStack.length == 0) |
| return exp; |
| } |
| else { |
| this._errors.push(TreeError.create(null, start.sourceSpan, "Invalid ICU message. Missing '}'.")); |
| return null; |
| } |
| } |
| if (this._peek.type === TokenType.EXPANSION_FORM_END) { |
| if (lastOnStack(expansionFormStack, TokenType.EXPANSION_FORM_START)) { |
| expansionFormStack.pop(); |
| } |
| else { |
| this._errors.push(TreeError.create(null, start.sourceSpan, "Invalid ICU message. Missing '}'.")); |
| return null; |
| } |
| } |
| if (this._peek.type === TokenType.EOF) { |
| this._errors.push(TreeError.create(null, start.sourceSpan, "Invalid ICU message. Missing '}'.")); |
| return null; |
| } |
| exp.push(this._advance()); |
| } |
| }; |
| _TreeBuilder.prototype._consumeText = function (token) { |
| var text = token.parts[0]; |
| if (text.length > 0 && text[0] == '\n') { |
| var parent_1 = this._getParentElement(); |
| if (parent_1 != null && parent_1.children.length == 0 && |
| this.getTagDefinition(parent_1.name).ignoreFirstLf) { |
| text = text.substring(1); |
| } |
| } |
| if (text.length > 0) { |
| this._addToParent(new Text$3(text, token.sourceSpan)); |
| } |
| }; |
| _TreeBuilder.prototype._closeVoidElement = function () { |
| var el = this._getParentElement(); |
| if (el && this.getTagDefinition(el.name).isVoid) { |
| this._elementStack.pop(); |
| } |
| }; |
| _TreeBuilder.prototype._consumeStartTag = function (startTagToken) { |
| var prefix = startTagToken.parts[0]; |
| var name = startTagToken.parts[1]; |
| var attrs = []; |
| while (this._peek.type === TokenType.ATTR_NAME) { |
| attrs.push(this._consumeAttr(this._advance())); |
| } |
| var fullName = this._getElementFullName(prefix, name, this._getParentElement()); |
| var selfClosing = false; |
| // Note: There could have been a tokenizer error |
| // so that we don't get a token for the end tag... |
| if (this._peek.type === TokenType.TAG_OPEN_END_VOID) { |
| this._advance(); |
| selfClosing = true; |
| var tagDef = this.getTagDefinition(fullName); |
| if (!(tagDef.canSelfClose || getNsPrefix(fullName) !== null || tagDef.isVoid)) { |
| this._errors.push(TreeError.create(fullName, startTagToken.sourceSpan, "Only void and foreign elements can be self closed \"" + startTagToken.parts[1] + "\"")); |
| } |
| } |
| else if (this._peek.type === TokenType.TAG_OPEN_END) { |
| this._advance(); |
| selfClosing = false; |
| } |
| var end = this._peek.sourceSpan.start; |
| var span = new ParseSourceSpan(startTagToken.sourceSpan.start, end); |
| var el = new Element$1(fullName, attrs, [], span, span, undefined); |
| this._pushElement(el); |
| if (selfClosing) { |
| this._popElement(fullName); |
| el.endSourceSpan = span; |
| } |
| }; |
| _TreeBuilder.prototype._pushElement = function (el) { |
| var parentEl = this._getParentElement(); |
| if (parentEl && this.getTagDefinition(parentEl.name).isClosedByChild(el.name)) { |
| this._elementStack.pop(); |
| } |
| this._addToParent(el); |
| this._elementStack.push(el); |
| }; |
| _TreeBuilder.prototype._consumeEndTag = function (endTagToken) { |
| var fullName = this._getElementFullName(endTagToken.parts[0], endTagToken.parts[1], this._getParentElement()); |
| if (this._getParentElement()) { |
| this._getParentElement().endSourceSpan = endTagToken.sourceSpan; |
| } |
| if (this.getTagDefinition(fullName).isVoid) { |
| this._errors.push(TreeError.create(fullName, endTagToken.sourceSpan, "Void elements do not have end tags \"" + endTagToken.parts[1] + "\"")); |
| } |
| else if (!this._popElement(fullName)) { |
| var errMsg = "Unexpected closing tag \"" + fullName + "\". It may happen when the tag has already been closed by another tag. For more info see https://www.w3.org/TR/html5/syntax.html#closing-elements-that-have-implied-end-tags"; |
| this._errors.push(TreeError.create(fullName, endTagToken.sourceSpan, errMsg)); |
| } |
| }; |
| _TreeBuilder.prototype._popElement = function (fullName) { |
| for (var stackIndex = this._elementStack.length - 1; stackIndex >= 0; stackIndex--) { |
| var el = this._elementStack[stackIndex]; |
| if (el.name == fullName) { |
| this._elementStack.splice(stackIndex, this._elementStack.length - stackIndex); |
| return true; |
| } |
| if (!this.getTagDefinition(el.name).closedByParent) { |
| return false; |
| } |
| } |
| return false; |
| }; |
| _TreeBuilder.prototype._consumeAttr = function (attrName) { |
| var fullName = mergeNsAndName(attrName.parts[0], attrName.parts[1]); |
| var end = attrName.sourceSpan.end; |
| var value = ''; |
| var valueSpan = undefined; |
| if (this._peek.type === TokenType.ATTR_QUOTE) { |
| this._advance(); |
| } |
| if (this._peek.type === TokenType.ATTR_VALUE) { |
| var valueToken = this._advance(); |
| value = valueToken.parts[0]; |
| end = valueToken.sourceSpan.end; |
| valueSpan = valueToken.sourceSpan; |
| } |
| if (this._peek.type === TokenType.ATTR_QUOTE) { |
| var quoteToken = this._advance(); |
| end = quoteToken.sourceSpan.end; |
| } |
| return new Attribute(fullName, value, new ParseSourceSpan(attrName.sourceSpan.start, end), valueSpan); |
| }; |
| _TreeBuilder.prototype._getParentElement = function () { |
| return this._elementStack.length > 0 ? this._elementStack[this._elementStack.length - 1] : null; |
| }; |
| /** |
| * Returns the parent in the DOM and the container. |
| * |
| * `<ng-container>` elements are skipped as they are not rendered as DOM element. |
| */ |
| _TreeBuilder.prototype._getParentElementSkippingContainers = function () { |
| var container = null; |
| for (var i = this._elementStack.length - 1; i >= 0; i--) { |
| if (!isNgContainer(this._elementStack[i].name)) { |
| return { parent: this._elementStack[i], container: container }; |
| } |
| container = this._elementStack[i]; |
| } |
| return { parent: null, container: container }; |
| }; |
| _TreeBuilder.prototype._addToParent = function (node) { |
| var parent = this._getParentElement(); |
| if (parent != null) { |
| parent.children.push(node); |
| } |
| else { |
| this._rootNodes.push(node); |
| } |
| }; |
| /** |
| * Insert a node between the parent and the container. |
| * When no container is given, the node is appended as a child of the parent. |
| * Also updates the element stack accordingly. |
| * |
| * @internal |
| */ |
| _TreeBuilder.prototype._insertBeforeContainer = function (parent, container, node) { |
| if (!container) { |
| this._addToParent(node); |
| this._elementStack.push(node); |
| } |
| else { |
| if (parent) { |
| // replace the container with the new node in the children |
| var index = parent.children.indexOf(container); |
| parent.children[index] = node; |
| } |
| else { |
| this._rootNodes.push(node); |
| } |
| node.children.push(container); |
| this._elementStack.splice(this._elementStack.indexOf(container), 0, node); |
| } |
| }; |
| _TreeBuilder.prototype._getElementFullName = function (prefix, localName, parentElement) { |
| if (prefix === '') { |
| prefix = this.getTagDefinition(localName).implicitNamespacePrefix || ''; |
| if (prefix === '' && parentElement != null) { |
| prefix = getNsPrefix(parentElement.name); |
| } |
| } |
| return mergeNsAndName(prefix, localName); |
| }; |
| return _TreeBuilder; |
| }()); |
| function lastOnStack(stack, element) { |
| return stack.length > 0 && stack[stack.length - 1] === element; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var HtmlParser = /** @class */ (function (_super) { |
| __extends(HtmlParser, _super); |
| function HtmlParser() { |
| return _super.call(this, getHtmlTagDefinition) || this; |
| } |
| HtmlParser.prototype.parse = function (source, url, options) { |
| return _super.prototype.parse.call(this, source, url, options); |
| }; |
| return HtmlParser; |
| }(Parser)); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var PRESERVE_WS_ATTR_NAME = 'ngPreserveWhitespaces'; |
| var SKIP_WS_TRIM_TAGS = new Set(['pre', 'template', 'textarea', 'script', 'style']); |
| // Equivalent to \s with \u00a0 (non-breaking space) excluded. |
| // Based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp |
| var WS_CHARS = ' \f\n\r\t\v\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff'; |
| var NO_WS_REGEXP = new RegExp("[^" + WS_CHARS + "]"); |
| var WS_REPLACE_REGEXP = new RegExp("[" + WS_CHARS + "]{2,}", 'g'); |
| function hasPreserveWhitespacesAttr(attrs) { |
| return attrs.some(function (attr) { return attr.name === PRESERVE_WS_ATTR_NAME; }); |
| } |
| /** |
| * Angular Dart introduced &ngsp; as a placeholder for non-removable space, see: |
| * https://github.com/dart-lang/angular/blob/0bb611387d29d65b5af7f9d2515ab571fd3fbee4/_tests/test/compiler/preserve_whitespace_test.dart#L25-L32 |
| * In Angular Dart &ngsp; is converted to the 0xE500 PUA (Private Use Areas) unicode character |
| * and later on replaced by a space. We are re-implementing the same idea here. |
| */ |
| function replaceNgsp(value) { |
| // lexer is replacing the &ngsp; pseudo-entity with NGSP_UNICODE |
| return value.replace(new RegExp(NGSP_UNICODE, 'g'), ' '); |
| } |
| /** |
| * This visitor can walk HTML parse tree and remove / trim text nodes using the following rules: |
| * - consider spaces, tabs and new lines as whitespace characters; |
| * - drop text nodes consisting of whitespace characters only; |
| * - for all other text nodes replace consecutive whitespace characters with one space; |
| * - convert &ngsp; pseudo-entity to a single space; |
| * |
| * Removal and trimming of whitespaces have positive performance impact (less code to generate |
| * while compiling templates, faster view creation). At the same time it can be "destructive" |
| * in some cases (whitespaces can influence layout). Because of the potential of breaking layout |
| * this visitor is not activated by default in Angular 5 and people need to explicitly opt-in for |
| * whitespace removal. The default option for whitespace removal will be revisited in Angular 6 |
| * and might be changed to "on" by default. |
| */ |
| var WhitespaceVisitor = /** @class */ (function () { |
| function WhitespaceVisitor() { |
| } |
| WhitespaceVisitor.prototype.visitElement = function (element, context) { |
| if (SKIP_WS_TRIM_TAGS.has(element.name) || hasPreserveWhitespacesAttr(element.attrs)) { |
| // don't descent into elements where we need to preserve whitespaces |
| // but still visit all attributes to eliminate one used as a market to preserve WS |
| return new Element$1(element.name, visitAll$1(this, element.attrs), element.children, element.sourceSpan, element.startSourceSpan, element.endSourceSpan, element.i18n); |
| } |
| return new Element$1(element.name, element.attrs, visitAll$1(this, element.children), element.sourceSpan, element.startSourceSpan, element.endSourceSpan, element.i18n); |
| }; |
| WhitespaceVisitor.prototype.visitAttribute = function (attribute, context) { |
| return attribute.name !== PRESERVE_WS_ATTR_NAME ? attribute : null; |
| }; |
| WhitespaceVisitor.prototype.visitText = function (text, context) { |
| var isNotBlank = text.value.match(NO_WS_REGEXP); |
| if (isNotBlank) { |
| return new Text$3(replaceNgsp(text.value).replace(WS_REPLACE_REGEXP, ' '), text.sourceSpan, text.i18n); |
| } |
| return null; |
| }; |
| WhitespaceVisitor.prototype.visitComment = function (comment, context) { return comment; }; |
| WhitespaceVisitor.prototype.visitExpansion = function (expansion, context) { return expansion; }; |
| WhitespaceVisitor.prototype.visitExpansionCase = function (expansionCase, context) { return expansionCase; }; |
| return WhitespaceVisitor; |
| }()); |
| function removeWhitespaces(htmlAstWithErrors) { |
| return new ParseTreeResult(visitAll$1(new WhitespaceVisitor(), htmlAstWithErrors.rootNodes), htmlAstWithErrors.errors); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| // http://cldr.unicode.org/index/cldr-spec/plural-rules |
| var PLURAL_CASES = ['zero', 'one', 'two', 'few', 'many', 'other']; |
| /** |
| * Expands special forms into elements. |
| * |
| * For example, |
| * |
| * ``` |
| * { messages.length, plural, |
| * =0 {zero} |
| * =1 {one} |
| * other {more than one} |
| * } |
| * ``` |
| * |
| * will be expanded into |
| * |
| * ``` |
| * <ng-container [ngPlural]="messages.length"> |
| * <ng-template ngPluralCase="=0">zero</ng-template> |
| * <ng-template ngPluralCase="=1">one</ng-template> |
| * <ng-template ngPluralCase="other">more than one</ng-template> |
| * </ng-container> |
| * ``` |
| */ |
| function expandNodes(nodes) { |
| var expander = new _Expander(); |
| return new ExpansionResult(visitAll$1(expander, nodes), expander.isExpanded, expander.errors); |
| } |
| var ExpansionResult = /** @class */ (function () { |
| function ExpansionResult(nodes, expanded, errors) { |
| this.nodes = nodes; |
| this.expanded = expanded; |
| this.errors = errors; |
| } |
| return ExpansionResult; |
| }()); |
| var ExpansionError = /** @class */ (function (_super) { |
| __extends(ExpansionError, _super); |
| function ExpansionError(span, errorMsg) { |
| return _super.call(this, span, errorMsg) || this; |
| } |
| return ExpansionError; |
| }(ParseError)); |
| /** |
| * Expand expansion forms (plural, select) to directives |
| * |
| * @internal |
| */ |
| var _Expander = /** @class */ (function () { |
| function _Expander() { |
| this.isExpanded = false; |
| this.errors = []; |
| } |
| _Expander.prototype.visitElement = function (element, context) { |
| return new Element$1(element.name, element.attrs, visitAll$1(this, element.children), element.sourceSpan, element.startSourceSpan, element.endSourceSpan); |
| }; |
| _Expander.prototype.visitAttribute = function (attribute, context) { return attribute; }; |
| _Expander.prototype.visitText = function (text, context) { return text; }; |
| _Expander.prototype.visitComment = function (comment, context) { return comment; }; |
| _Expander.prototype.visitExpansion = function (icu, context) { |
| this.isExpanded = true; |
| return icu.type == 'plural' ? _expandPluralForm(icu, this.errors) : |
| _expandDefaultForm(icu, this.errors); |
| }; |
| _Expander.prototype.visitExpansionCase = function (icuCase, context) { |
| throw new Error('Should not be reached'); |
| }; |
| return _Expander; |
| }()); |
| // Plural forms are expanded to `NgPlural` and `NgPluralCase`s |
| function _expandPluralForm(ast, errors) { |
| var children = ast.cases.map(function (c) { |
| if (PLURAL_CASES.indexOf(c.value) == -1 && !c.value.match(/^=\d+$/)) { |
| errors.push(new ExpansionError(c.valueSourceSpan, "Plural cases should be \"=<number>\" or one of " + PLURAL_CASES.join(", "))); |
| } |
| var expansionResult = expandNodes(c.expression); |
| errors.push.apply(errors, __spread(expansionResult.errors)); |
| return new Element$1("ng-template", [new Attribute('ngPluralCase', "" + c.value, c.valueSourceSpan)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan); |
| }); |
| var switchAttr = new Attribute('[ngPlural]', ast.switchValue, ast.switchValueSourceSpan); |
| return new Element$1('ng-container', [switchAttr], children, ast.sourceSpan, ast.sourceSpan, ast.sourceSpan); |
| } |
| // ICU messages (excluding plural form) are expanded to `NgSwitch` and `NgSwitchCase`s |
| function _expandDefaultForm(ast, errors) { |
| var children = ast.cases.map(function (c) { |
| var expansionResult = expandNodes(c.expression); |
| errors.push.apply(errors, __spread(expansionResult.errors)); |
| if (c.value === 'other') { |
| // other is the default case when no values match |
| return new Element$1("ng-template", [new Attribute('ngSwitchDefault', '', c.valueSourceSpan)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan); |
| } |
| return new Element$1("ng-template", [new Attribute('ngSwitchCase', "" + c.value, c.valueSourceSpan)], expansionResult.nodes, c.sourceSpan, c.sourceSpan, c.sourceSpan); |
| }); |
| var switchAttr = new Attribute('[ngSwitch]', ast.switchValue, ast.switchValueSourceSpan); |
| return new Element$1('ng-container', [switchAttr], children, ast.sourceSpan, ast.sourceSpan, ast.sourceSpan); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var _a; |
| /** |
| * A segment of text within the template. |
| */ |
| var TextAst = /** @class */ (function () { |
| function TextAst(value, ngContentIndex, sourceSpan) { |
| this.value = value; |
| this.ngContentIndex = ngContentIndex; |
| this.sourceSpan = sourceSpan; |
| } |
| TextAst.prototype.visit = function (visitor, context) { return visitor.visitText(this, context); }; |
| return TextAst; |
| }()); |
| /** |
| * A bound expression within the text of a template. |
| */ |
| var BoundTextAst = /** @class */ (function () { |
| function BoundTextAst(value, ngContentIndex, sourceSpan) { |
| this.value = value; |
| this.ngContentIndex = ngContentIndex; |
| this.sourceSpan = sourceSpan; |
| } |
| BoundTextAst.prototype.visit = function (visitor, context) { |
| return visitor.visitBoundText(this, context); |
| }; |
| return BoundTextAst; |
| }()); |
| /** |
| * A plain attribute on an element. |
| */ |
| var AttrAst = /** @class */ (function () { |
| function AttrAst(name, value, sourceSpan) { |
| this.name = name; |
| this.value = value; |
| this.sourceSpan = sourceSpan; |
| } |
| AttrAst.prototype.visit = function (visitor, context) { return visitor.visitAttr(this, context); }; |
| return AttrAst; |
| }()); |
| var BoundPropertyMapping = (_a = {}, |
| _a[4 /* Animation */] = 4 /* Animation */, |
| _a[1 /* Attribute */] = 1 /* Attribute */, |
| _a[2 /* Class */] = 2 /* Class */, |
| _a[0 /* Property */] = 0 /* Property */, |
| _a[3 /* Style */] = 3 /* Style */, |
| _a); |
| /** |
| * A binding for an element property (e.g. `[property]="expression"`) or an animation trigger (e.g. |
| * `[@trigger]="stateExp"`) |
| */ |
| var BoundElementPropertyAst = /** @class */ (function () { |
| function BoundElementPropertyAst(name, type, securityContext, value, unit, sourceSpan) { |
| this.name = name; |
| this.type = type; |
| this.securityContext = securityContext; |
| this.value = value; |
| this.unit = unit; |
| this.sourceSpan = sourceSpan; |
| this.isAnimation = this.type === 4 /* Animation */; |
| } |
| BoundElementPropertyAst.fromBoundProperty = function (prop) { |
| var type = BoundPropertyMapping[prop.type]; |
| return new BoundElementPropertyAst(prop.name, type, prop.securityContext, prop.value, prop.unit, prop.sourceSpan); |
| }; |
| BoundElementPropertyAst.prototype.visit = function (visitor, context) { |
| return visitor.visitElementProperty(this, context); |
| }; |
| return BoundElementPropertyAst; |
| }()); |
| /** |
| * A binding for an element event (e.g. `(event)="handler()"`) or an animation trigger event (e.g. |
| * `(@trigger.phase)="callback($event)"`). |
| */ |
| var BoundEventAst = /** @class */ (function () { |
| function BoundEventAst(name, target, phase, handler, sourceSpan, handlerSpan) { |
| this.name = name; |
| this.target = target; |
| this.phase = phase; |
| this.handler = handler; |
| this.sourceSpan = sourceSpan; |
| this.handlerSpan = handlerSpan; |
| this.fullName = BoundEventAst.calcFullName(this.name, this.target, this.phase); |
| this.isAnimation = !!this.phase; |
| } |
| BoundEventAst.calcFullName = function (name, target, phase) { |
| if (target) { |
| return target + ":" + name; |
| } |
| if (phase) { |
| return "@" + name + "." + phase; |
| } |
| return name; |
| }; |
| BoundEventAst.fromParsedEvent = function (event) { |
| var target = event.type === 0 /* Regular */ ? event.targetOrPhase : null; |
| var phase = event.type === 1 /* Animation */ ? event.targetOrPhase : null; |
| return new BoundEventAst(event.name, target, phase, event.handler, event.sourceSpan, event.handlerSpan); |
| }; |
| BoundEventAst.prototype.visit = function (visitor, context) { |
| return visitor.visitEvent(this, context); |
| }; |
| return BoundEventAst; |
| }()); |
| /** |
| * A reference declaration on an element (e.g. `let someName="expression"`). |
| */ |
| var ReferenceAst = /** @class */ (function () { |
| function ReferenceAst(name, value, originalValue, sourceSpan) { |
| this.name = name; |
| this.value = value; |
| this.originalValue = originalValue; |
| this.sourceSpan = sourceSpan; |
| } |
| ReferenceAst.prototype.visit = function (visitor, context) { |
| return visitor.visitReference(this, context); |
| }; |
| return ReferenceAst; |
| }()); |
| /** |
| * A variable declaration on a <ng-template> (e.g. `var-someName="someLocalName"`). |
| */ |
| var VariableAst = /** @class */ (function () { |
| function VariableAst(name, value, sourceSpan) { |
| this.name = name; |
| this.value = value; |
| this.sourceSpan = sourceSpan; |
| } |
| VariableAst.fromParsedVariable = function (v) { |
| return new VariableAst(v.name, v.value, v.sourceSpan); |
| }; |
| VariableAst.prototype.visit = function (visitor, context) { |
| return visitor.visitVariable(this, context); |
| }; |
| return VariableAst; |
| }()); |
| /** |
| * An element declaration in a template. |
| */ |
| var ElementAst = /** @class */ (function () { |
| function ElementAst(name, attrs, inputs, outputs, references, directives, providers, hasViewContainer, queryMatches, children, ngContentIndex, sourceSpan, endSourceSpan) { |
| this.name = name; |
| this.attrs = attrs; |
| this.inputs = inputs; |
| this.outputs = outputs; |
| this.references = references; |
| this.directives = directives; |
| this.providers = providers; |
| this.hasViewContainer = hasViewContainer; |
| this.queryMatches = queryMatches; |
| this.children = children; |
| this.ngContentIndex = ngContentIndex; |
| this.sourceSpan = sourceSpan; |
| this.endSourceSpan = endSourceSpan; |
| } |
| ElementAst.prototype.visit = function (visitor, context) { |
| return visitor.visitElement(this, context); |
| }; |
| return ElementAst; |
| }()); |
| /** |
| * A `<ng-template>` element included in an Angular template. |
| */ |
| var EmbeddedTemplateAst = /** @class */ (function () { |
| function EmbeddedTemplateAst(attrs, outputs, references, variables, directives, providers, hasViewContainer, queryMatches, children, ngContentIndex, sourceSpan) { |
| this.attrs = attrs; |
| this.outputs = outputs; |
| this.references = references; |
| this.variables = variables; |
| this.directives = directives; |
| this.providers = providers; |
| this.hasViewContainer = hasViewContainer; |
| this.queryMatches = queryMatches; |
| this.children = children; |
| this.ngContentIndex = ngContentIndex; |
| this.sourceSpan = sourceSpan; |
| } |
| EmbeddedTemplateAst.prototype.visit = function (visitor, context) { |
| return visitor.visitEmbeddedTemplate(this, context); |
| }; |
| return EmbeddedTemplateAst; |
| }()); |
| /** |
| * A directive property with a bound value (e.g. `*ngIf="condition"). |
| */ |
| var BoundDirectivePropertyAst = /** @class */ (function () { |
| function BoundDirectivePropertyAst(directiveName, templateName, value, sourceSpan) { |
| this.directiveName = directiveName; |
| this.templateName = templateName; |
| this.value = value; |
| this.sourceSpan = sourceSpan; |
| } |
| BoundDirectivePropertyAst.prototype.visit = function (visitor, context) { |
| return visitor.visitDirectiveProperty(this, context); |
| }; |
| return BoundDirectivePropertyAst; |
| }()); |
| /** |
| * A directive declared on an element. |
| */ |
| var DirectiveAst = /** @class */ (function () { |
| function DirectiveAst(directive, inputs, hostProperties, hostEvents, contentQueryStartId, sourceSpan) { |
| this.directive = directive; |
| this.inputs = inputs; |
| this.hostProperties = hostProperties; |
| this.hostEvents = hostEvents; |
| this.contentQueryStartId = contentQueryStartId; |
| this.sourceSpan = sourceSpan; |
| } |
| DirectiveAst.prototype.visit = function (visitor, context) { |
| return visitor.visitDirective(this, context); |
| }; |
| return DirectiveAst; |
| }()); |
| /** |
| * A provider declared on an element |
| */ |
| var ProviderAst = /** @class */ (function () { |
| function ProviderAst(token, multiProvider, eager, providers, providerType, lifecycleHooks, sourceSpan, isModule) { |
| this.token = token; |
| this.multiProvider = multiProvider; |
| this.eager = eager; |
| this.providers = providers; |
| this.providerType = providerType; |
| this.lifecycleHooks = lifecycleHooks; |
| this.sourceSpan = sourceSpan; |
| this.isModule = isModule; |
| } |
| ProviderAst.prototype.visit = function (visitor, context) { |
| // No visit method in the visitor for now... |
| return null; |
| }; |
| return ProviderAst; |
| }()); |
| (function (ProviderAstType) { |
| ProviderAstType[ProviderAstType["PublicService"] = 0] = "PublicService"; |
| ProviderAstType[ProviderAstType["PrivateService"] = 1] = "PrivateService"; |
| ProviderAstType[ProviderAstType["Component"] = 2] = "Component"; |
| ProviderAstType[ProviderAstType["Directive"] = 3] = "Directive"; |
| ProviderAstType[ProviderAstType["Builtin"] = 4] = "Builtin"; |
| })(exports.ProviderAstType || (exports.ProviderAstType = {})); |
| /** |
| * Position where content is to be projected (instance of `<ng-content>` in a template). |
| */ |
| var NgContentAst = /** @class */ (function () { |
| function NgContentAst(index, ngContentIndex, sourceSpan) { |
| this.index = index; |
| this.ngContentIndex = ngContentIndex; |
| this.sourceSpan = sourceSpan; |
| } |
| NgContentAst.prototype.visit = function (visitor, context) { |
| return visitor.visitNgContent(this, context); |
| }; |
| return NgContentAst; |
| }()); |
| /** |
| * A visitor that accepts each node but doesn't do anything. It is intended to be used |
| * as the base class for a visitor that is only interested in a subset of the node types. |
| */ |
| var NullTemplateVisitor = /** @class */ (function () { |
| function NullTemplateVisitor() { |
| } |
| NullTemplateVisitor.prototype.visitNgContent = function (ast, context) { }; |
| NullTemplateVisitor.prototype.visitEmbeddedTemplate = function (ast, context) { }; |
| NullTemplateVisitor.prototype.visitElement = function (ast, context) { }; |
| NullTemplateVisitor.prototype.visitReference = function (ast, context) { }; |
| NullTemplateVisitor.prototype.visitVariable = function (ast, context) { }; |
| NullTemplateVisitor.prototype.visitEvent = function (ast, context) { }; |
| NullTemplateVisitor.prototype.visitElementProperty = function (ast, context) { }; |
| NullTemplateVisitor.prototype.visitAttr = function (ast, context) { }; |
| NullTemplateVisitor.prototype.visitBoundText = function (ast, context) { }; |
| NullTemplateVisitor.prototype.visitText = function (ast, context) { }; |
| NullTemplateVisitor.prototype.visitDirective = function (ast, context) { }; |
| NullTemplateVisitor.prototype.visitDirectiveProperty = function (ast, context) { }; |
| return NullTemplateVisitor; |
| }()); |
| /** |
| * Base class that can be used to build a visitor that visits each node |
| * in an template ast recursively. |
| */ |
| var RecursiveTemplateAstVisitor = /** @class */ (function (_super) { |
| __extends(RecursiveTemplateAstVisitor, _super); |
| function RecursiveTemplateAstVisitor() { |
| return _super.call(this) || this; |
| } |
| // Nodes with children |
| RecursiveTemplateAstVisitor.prototype.visitEmbeddedTemplate = function (ast, context) { |
| return this.visitChildren(context, function (visit) { |
| visit(ast.attrs); |
| visit(ast.references); |
| visit(ast.variables); |
| visit(ast.directives); |
| visit(ast.providers); |
| visit(ast.children); |
| }); |
| }; |
| RecursiveTemplateAstVisitor.prototype.visitElement = function (ast, context) { |
| return this.visitChildren(context, function (visit) { |
| visit(ast.attrs); |
| visit(ast.inputs); |
| visit(ast.outputs); |
| visit(ast.references); |
| visit(ast.directives); |
| visit(ast.providers); |
| visit(ast.children); |
| }); |
| }; |
| RecursiveTemplateAstVisitor.prototype.visitDirective = function (ast, context) { |
| return this.visitChildren(context, function (visit) { |
| visit(ast.inputs); |
| visit(ast.hostProperties); |
| visit(ast.hostEvents); |
| }); |
| }; |
| RecursiveTemplateAstVisitor.prototype.visitChildren = function (context, cb) { |
| var results = []; |
| var t = this; |
| function visit(children) { |
| if (children && children.length) |
| results.push(templateVisitAll(t, children, context)); |
| } |
| cb(visit); |
| return [].concat.apply([], results); |
| }; |
| return RecursiveTemplateAstVisitor; |
| }(NullTemplateVisitor)); |
| /** |
| * Visit every node in a list of {@link TemplateAst}s with the given {@link TemplateAstVisitor}. |
| */ |
| function templateVisitAll(visitor, asts, context) { |
| if (context === void 0) { context = null; } |
| var result = []; |
| var visit = visitor.visit ? |
| function (ast) { return visitor.visit(ast, context) || ast.visit(visitor, context); } : |
| function (ast) { return ast.visit(visitor, context); }; |
| asts.forEach(function (ast) { |
| var astResult = visit(ast); |
| if (astResult) { |
| result.push(astResult); |
| } |
| }); |
| return result; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var ProviderError = /** @class */ (function (_super) { |
| __extends(ProviderError, _super); |
| function ProviderError(message, span) { |
| return _super.call(this, span, message) || this; |
| } |
| return ProviderError; |
| }(ParseError)); |
| var ProviderViewContext = /** @class */ (function () { |
| function ProviderViewContext(reflector, component) { |
| var _this = this; |
| this.reflector = reflector; |
| this.component = component; |
| this.errors = []; |
| this.viewQueries = _getViewQueries(component); |
| this.viewProviders = new Map(); |
| component.viewProviders.forEach(function (provider) { |
| if (_this.viewProviders.get(tokenReference(provider.token)) == null) { |
| _this.viewProviders.set(tokenReference(provider.token), true); |
| } |
| }); |
| } |
| return ProviderViewContext; |
| }()); |
| var ProviderElementContext = /** @class */ (function () { |
| function ProviderElementContext(viewContext, _parent, _isViewRoot, _directiveAsts, attrs, refs, isTemplate, contentQueryStartId, _sourceSpan) { |
| var _this = this; |
| this.viewContext = viewContext; |
| this._parent = _parent; |
| this._isViewRoot = _isViewRoot; |
| this._directiveAsts = _directiveAsts; |
| this._sourceSpan = _sourceSpan; |
| this._transformedProviders = new Map(); |
| this._seenProviders = new Map(); |
| this._queriedTokens = new Map(); |
| this.transformedHasViewContainer = false; |
| this._attrs = {}; |
| attrs.forEach(function (attrAst) { return _this._attrs[attrAst.name] = attrAst.value; }); |
| var directivesMeta = _directiveAsts.map(function (directiveAst) { return directiveAst.directive; }); |
| this._allProviders = |
| _resolveProvidersFromDirectives(directivesMeta, _sourceSpan, viewContext.errors); |
| this._contentQueries = _getContentQueries(contentQueryStartId, directivesMeta); |
| Array.from(this._allProviders.values()).forEach(function (provider) { |
| _this._addQueryReadsTo(provider.token, provider.token, _this._queriedTokens); |
| }); |
| if (isTemplate) { |
| var templateRefId = createTokenForExternalReference(this.viewContext.reflector, Identifiers.TemplateRef); |
| this._addQueryReadsTo(templateRefId, templateRefId, this._queriedTokens); |
| } |
| refs.forEach(function (refAst) { |
| var defaultQueryValue = refAst.value || |
| createTokenForExternalReference(_this.viewContext.reflector, Identifiers.ElementRef); |
| _this._addQueryReadsTo({ value: refAst.name }, defaultQueryValue, _this._queriedTokens); |
| }); |
| if (this._queriedTokens.get(this.viewContext.reflector.resolveExternalReference(Identifiers.ViewContainerRef))) { |
| this.transformedHasViewContainer = true; |
| } |
| // create the providers that we know are eager first |
| Array.from(this._allProviders.values()).forEach(function (provider) { |
| var eager = provider.eager || _this._queriedTokens.get(tokenReference(provider.token)); |
| if (eager) { |
| _this._getOrCreateLocalProvider(provider.providerType, provider.token, true); |
| } |
| }); |
| } |
| ProviderElementContext.prototype.afterElement = function () { |
| var _this = this; |
| // collect lazy providers |
| Array.from(this._allProviders.values()).forEach(function (provider) { |
| _this._getOrCreateLocalProvider(provider.providerType, provider.token, false); |
| }); |
| }; |
| Object.defineProperty(ProviderElementContext.prototype, "transformProviders", { |
| get: function () { |
| // Note: Maps keep their insertion order. |
| var lazyProviders = []; |
| var eagerProviders = []; |
| this._transformedProviders.forEach(function (provider) { |
| if (provider.eager) { |
| eagerProviders.push(provider); |
| } |
| else { |
| lazyProviders.push(provider); |
| } |
| }); |
| return lazyProviders.concat(eagerProviders); |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(ProviderElementContext.prototype, "transformedDirectiveAsts", { |
| get: function () { |
| var sortedProviderTypes = this.transformProviders.map(function (provider) { return provider.token.identifier; }); |
| var sortedDirectives = this._directiveAsts.slice(); |
| sortedDirectives.sort(function (dir1, dir2) { return sortedProviderTypes.indexOf(dir1.directive.type) - |
| sortedProviderTypes.indexOf(dir2.directive.type); }); |
| return sortedDirectives; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(ProviderElementContext.prototype, "queryMatches", { |
| get: function () { |
| var allMatches = []; |
| this._queriedTokens.forEach(function (matches) { allMatches.push.apply(allMatches, __spread(matches)); }); |
| return allMatches; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| ProviderElementContext.prototype._addQueryReadsTo = function (token, defaultValue, queryReadTokens) { |
| this._getQueriesFor(token).forEach(function (query) { |
| var queryValue = query.meta.read || defaultValue; |
| var tokenRef = tokenReference(queryValue); |
| var queryMatches = queryReadTokens.get(tokenRef); |
| if (!queryMatches) { |
| queryMatches = []; |
| queryReadTokens.set(tokenRef, queryMatches); |
| } |
| queryMatches.push({ queryId: query.queryId, value: queryValue }); |
| }); |
| }; |
| ProviderElementContext.prototype._getQueriesFor = function (token) { |
| var result = []; |
| var currentEl = this; |
| var distance = 0; |
| var queries; |
| while (currentEl !== null) { |
| queries = currentEl._contentQueries.get(tokenReference(token)); |
| if (queries) { |
| result.push.apply(result, __spread(queries.filter(function (query) { return query.meta.descendants || distance <= 1; }))); |
| } |
| if (currentEl._directiveAsts.length > 0) { |
| distance++; |
| } |
| currentEl = currentEl._parent; |
| } |
| queries = this.viewContext.viewQueries.get(tokenReference(token)); |
| if (queries) { |
| result.push.apply(result, __spread(queries)); |
| } |
| return result; |
| }; |
| ProviderElementContext.prototype._getOrCreateLocalProvider = function (requestingProviderType, token, eager) { |
| var _this = this; |
| var resolvedProvider = this._allProviders.get(tokenReference(token)); |
| if (!resolvedProvider || ((requestingProviderType === exports.ProviderAstType.Directive || |
| requestingProviderType === exports.ProviderAstType.PublicService) && |
| resolvedProvider.providerType === exports.ProviderAstType.PrivateService) || |
| ((requestingProviderType === exports.ProviderAstType.PrivateService || |
| requestingProviderType === exports.ProviderAstType.PublicService) && |
| resolvedProvider.providerType === exports.ProviderAstType.Builtin)) { |
| return null; |
| } |
| var transformedProviderAst = this._transformedProviders.get(tokenReference(token)); |
| if (transformedProviderAst) { |
| return transformedProviderAst; |
| } |
| if (this._seenProviders.get(tokenReference(token)) != null) { |
| this.viewContext.errors.push(new ProviderError("Cannot instantiate cyclic dependency! " + tokenName(token), this._sourceSpan)); |
| return null; |
| } |
| this._seenProviders.set(tokenReference(token), true); |
| var transformedProviders = resolvedProvider.providers.map(function (provider) { |
| var transformedUseValue = provider.useValue; |
| var transformedUseExisting = provider.useExisting; |
| var transformedDeps = undefined; |
| if (provider.useExisting != null) { |
| var existingDiDep = _this._getDependency(resolvedProvider.providerType, { token: provider.useExisting }, eager); |
| if (existingDiDep.token != null) { |
| transformedUseExisting = existingDiDep.token; |
| } |
| else { |
| transformedUseExisting = null; |
| transformedUseValue = existingDiDep.value; |
| } |
| } |
| else if (provider.useFactory) { |
| var deps = provider.deps || provider.useFactory.diDeps; |
| transformedDeps = |
| deps.map(function (dep) { return _this._getDependency(resolvedProvider.providerType, dep, eager); }); |
| } |
| else if (provider.useClass) { |
| var deps = provider.deps || provider.useClass.diDeps; |
| transformedDeps = |
| deps.map(function (dep) { return _this._getDependency(resolvedProvider.providerType, dep, eager); }); |
| } |
| return _transformProvider(provider, { |
| useExisting: transformedUseExisting, |
| useValue: transformedUseValue, |
| deps: transformedDeps |
| }); |
| }); |
| transformedProviderAst = |
| _transformProviderAst(resolvedProvider, { eager: eager, providers: transformedProviders }); |
| this._transformedProviders.set(tokenReference(token), transformedProviderAst); |
| return transformedProviderAst; |
| }; |
| ProviderElementContext.prototype._getLocalDependency = function (requestingProviderType, dep, eager) { |
| if (eager === void 0) { eager = false; } |
| if (dep.isAttribute) { |
| var attrValue = this._attrs[dep.token.value]; |
| return { isValue: true, value: attrValue == null ? null : attrValue }; |
| } |
| if (dep.token != null) { |
| // access builtints |
| if ((requestingProviderType === exports.ProviderAstType.Directive || |
| requestingProviderType === exports.ProviderAstType.Component)) { |
| if (tokenReference(dep.token) === |
| this.viewContext.reflector.resolveExternalReference(Identifiers.Renderer) || |
| tokenReference(dep.token) === |
| this.viewContext.reflector.resolveExternalReference(Identifiers.ElementRef) || |
| tokenReference(dep.token) === |
| this.viewContext.reflector.resolveExternalReference(Identifiers.ChangeDetectorRef) || |
| tokenReference(dep.token) === |
| this.viewContext.reflector.resolveExternalReference(Identifiers.TemplateRef)) { |
| return dep; |
| } |
| if (tokenReference(dep.token) === |
| this.viewContext.reflector.resolveExternalReference(Identifiers.ViewContainerRef)) { |
| this.transformedHasViewContainer = true; |
| } |
| } |
| // access the injector |
| if (tokenReference(dep.token) === |
| this.viewContext.reflector.resolveExternalReference(Identifiers.Injector)) { |
| return dep; |
| } |
| // access providers |
| if (this._getOrCreateLocalProvider(requestingProviderType, dep.token, eager) != null) { |
| return dep; |
| } |
| } |
| return null; |
| }; |
| ProviderElementContext.prototype._getDependency = function (requestingProviderType, dep, eager) { |
| if (eager === void 0) { eager = false; } |
| var currElement = this; |
| var currEager = eager; |
| var result = null; |
| if (!dep.isSkipSelf) { |
| result = this._getLocalDependency(requestingProviderType, dep, eager); |
| } |
| if (dep.isSelf) { |
| if (!result && dep.isOptional) { |
| result = { isValue: true, value: null }; |
| } |
| } |
| else { |
| // check parent elements |
| while (!result && currElement._parent) { |
| var prevElement = currElement; |
| currElement = currElement._parent; |
| if (prevElement._isViewRoot) { |
| currEager = false; |
| } |
| result = currElement._getLocalDependency(exports.ProviderAstType.PublicService, dep, currEager); |
| } |
| // check @Host restriction |
| if (!result) { |
| if (!dep.isHost || this.viewContext.component.isHost || |
| this.viewContext.component.type.reference === tokenReference(dep.token) || |
| this.viewContext.viewProviders.get(tokenReference(dep.token)) != null) { |
| result = dep; |
| } |
| else { |
| result = dep.isOptional ? { isValue: true, value: null } : null; |
| } |
| } |
| } |
| if (!result) { |
| this.viewContext.errors.push(new ProviderError("No provider for " + tokenName(dep.token), this._sourceSpan)); |
| } |
| return result; |
| }; |
| return ProviderElementContext; |
| }()); |
| var NgModuleProviderAnalyzer = /** @class */ (function () { |
| function NgModuleProviderAnalyzer(reflector, ngModule, extraProviders, sourceSpan) { |
| var _this = this; |
| this.reflector = reflector; |
| this._transformedProviders = new Map(); |
| this._seenProviders = new Map(); |
| this._errors = []; |
| this._allProviders = new Map(); |
| ngModule.transitiveModule.modules.forEach(function (ngModuleType) { |
| var ngModuleProvider = { token: { identifier: ngModuleType }, useClass: ngModuleType }; |
| _resolveProviders([ngModuleProvider], exports.ProviderAstType.PublicService, true, sourceSpan, _this._errors, _this._allProviders, /* isModule */ true); |
| }); |
| _resolveProviders(ngModule.transitiveModule.providers.map(function (entry) { return entry.provider; }).concat(extraProviders), exports.ProviderAstType.PublicService, false, sourceSpan, this._errors, this._allProviders, |
| /* isModule */ false); |
| } |
| NgModuleProviderAnalyzer.prototype.parse = function () { |
| var _this = this; |
| Array.from(this._allProviders.values()).forEach(function (provider) { |
| _this._getOrCreateLocalProvider(provider.token, provider.eager); |
| }); |
| if (this._errors.length > 0) { |
| var errorString = this._errors.join('\n'); |
| throw new Error("Provider parse errors:\n" + errorString); |
| } |
| // Note: Maps keep their insertion order. |
| var lazyProviders = []; |
| var eagerProviders = []; |
| this._transformedProviders.forEach(function (provider) { |
| if (provider.eager) { |
| eagerProviders.push(provider); |
| } |
| else { |
| lazyProviders.push(provider); |
| } |
| }); |
| return lazyProviders.concat(eagerProviders); |
| }; |
| NgModuleProviderAnalyzer.prototype._getOrCreateLocalProvider = function (token, eager) { |
| var _this = this; |
| var resolvedProvider = this._allProviders.get(tokenReference(token)); |
| if (!resolvedProvider) { |
| return null; |
| } |
| var transformedProviderAst = this._transformedProviders.get(tokenReference(token)); |
| if (transformedProviderAst) { |
| return transformedProviderAst; |
| } |
| if (this._seenProviders.get(tokenReference(token)) != null) { |
| this._errors.push(new ProviderError("Cannot instantiate cyclic dependency! " + tokenName(token), resolvedProvider.sourceSpan)); |
| return null; |
| } |
| this._seenProviders.set(tokenReference(token), true); |
| var transformedProviders = resolvedProvider.providers.map(function (provider) { |
| var transformedUseValue = provider.useValue; |
| var transformedUseExisting = provider.useExisting; |
| var transformedDeps = undefined; |
| if (provider.useExisting != null) { |
| var existingDiDep = _this._getDependency({ token: provider.useExisting }, eager, resolvedProvider.sourceSpan); |
| if (existingDiDep.token != null) { |
| transformedUseExisting = existingDiDep.token; |
| } |
| else { |
| transformedUseExisting = null; |
| transformedUseValue = existingDiDep.value; |
| } |
| } |
| else if (provider.useFactory) { |
| var deps = provider.deps || provider.useFactory.diDeps; |
| transformedDeps = |
| deps.map(function (dep) { return _this._getDependency(dep, eager, resolvedProvider.sourceSpan); }); |
| } |
| else if (provider.useClass) { |
| var deps = provider.deps || provider.useClass.diDeps; |
| transformedDeps = |
| deps.map(function (dep) { return _this._getDependency(dep, eager, resolvedProvider.sourceSpan); }); |
| } |
| return _transformProvider(provider, { |
| useExisting: transformedUseExisting, |
| useValue: transformedUseValue, |
| deps: transformedDeps |
| }); |
| }); |
| transformedProviderAst = |
| _transformProviderAst(resolvedProvider, { eager: eager, providers: transformedProviders }); |
| this._transformedProviders.set(tokenReference(token), transformedProviderAst); |
| return transformedProviderAst; |
| }; |
| NgModuleProviderAnalyzer.prototype._getDependency = function (dep, eager, requestorSourceSpan) { |
| if (eager === void 0) { eager = false; } |
| if (!dep.isSkipSelf && dep.token != null) { |
| // access the injector |
| if (tokenReference(dep.token) === |
| this.reflector.resolveExternalReference(Identifiers.Injector) || |
| tokenReference(dep.token) === |
| this.reflector.resolveExternalReference(Identifiers.ComponentFactoryResolver)) ; |
| else if (this._getOrCreateLocalProvider(dep.token, eager) != null) ; |
| } |
| return dep; |
| }; |
| return NgModuleProviderAnalyzer; |
| }()); |
| function _transformProvider(provider, _a) { |
| var useExisting = _a.useExisting, useValue = _a.useValue, deps = _a.deps; |
| return { |
| token: provider.token, |
| useClass: provider.useClass, |
| useExisting: useExisting, |
| useFactory: provider.useFactory, |
| useValue: useValue, |
| deps: deps, |
| multi: provider.multi |
| }; |
| } |
| function _transformProviderAst(provider, _a) { |
| var eager = _a.eager, providers = _a.providers; |
| return new ProviderAst(provider.token, provider.multiProvider, provider.eager || eager, providers, provider.providerType, provider.lifecycleHooks, provider.sourceSpan, provider.isModule); |
| } |
| function _resolveProvidersFromDirectives(directives, sourceSpan, targetErrors) { |
| var providersByToken = new Map(); |
| directives.forEach(function (directive) { |
| var dirProvider = { token: { identifier: directive.type }, useClass: directive.type }; |
| _resolveProviders([dirProvider], directive.isComponent ? exports.ProviderAstType.Component : exports.ProviderAstType.Directive, true, sourceSpan, targetErrors, providersByToken, /* isModule */ false); |
| }); |
| // Note: directives need to be able to overwrite providers of a component! |
| var directivesWithComponentFirst = directives.filter(function (dir) { return dir.isComponent; }).concat(directives.filter(function (dir) { return !dir.isComponent; })); |
| directivesWithComponentFirst.forEach(function (directive) { |
| _resolveProviders(directive.providers, exports.ProviderAstType.PublicService, false, sourceSpan, targetErrors, providersByToken, /* isModule */ false); |
| _resolveProviders(directive.viewProviders, exports.ProviderAstType.PrivateService, false, sourceSpan, targetErrors, providersByToken, /* isModule */ false); |
| }); |
| return providersByToken; |
| } |
| function _resolveProviders(providers, providerType, eager, sourceSpan, targetErrors, targetProvidersByToken, isModule) { |
| providers.forEach(function (provider) { |
| var resolvedProvider = targetProvidersByToken.get(tokenReference(provider.token)); |
| if (resolvedProvider != null && !!resolvedProvider.multiProvider !== !!provider.multi) { |
| targetErrors.push(new ProviderError("Mixing multi and non multi provider is not possible for token " + tokenName(resolvedProvider.token), sourceSpan)); |
| } |
| if (!resolvedProvider) { |
| var lifecycleHooks = provider.token.identifier && |
| provider.token.identifier.lifecycleHooks ? |
| provider.token.identifier.lifecycleHooks : |
| []; |
| var isUseValue = !(provider.useClass || provider.useExisting || provider.useFactory); |
| resolvedProvider = new ProviderAst(provider.token, !!provider.multi, eager || isUseValue, [provider], providerType, lifecycleHooks, sourceSpan, isModule); |
| targetProvidersByToken.set(tokenReference(provider.token), resolvedProvider); |
| } |
| else { |
| if (!provider.multi) { |
| resolvedProvider.providers.length = 0; |
| } |
| resolvedProvider.providers.push(provider); |
| } |
| }); |
| } |
| function _getViewQueries(component) { |
| // Note: queries start with id 1 so we can use the number in a Bloom filter! |
| var viewQueryId = 1; |
| var viewQueries = new Map(); |
| if (component.viewQueries) { |
| component.viewQueries.forEach(function (query) { return _addQueryToTokenMap(viewQueries, { meta: query, queryId: viewQueryId++ }); }); |
| } |
| return viewQueries; |
| } |
| function _getContentQueries(contentQueryStartId, directives) { |
| var contentQueryId = contentQueryStartId; |
| var contentQueries = new Map(); |
| directives.forEach(function (directive, directiveIndex) { |
| if (directive.queries) { |
| directive.queries.forEach(function (query) { return _addQueryToTokenMap(contentQueries, { meta: query, queryId: contentQueryId++ }); }); |
| } |
| }); |
| return contentQueries; |
| } |
| function _addQueryToTokenMap(map, query) { |
| query.meta.selectors.forEach(function (token) { |
| var entry = map.get(tokenReference(token)); |
| if (!entry) { |
| entry = []; |
| map.set(tokenReference(token), entry); |
| } |
| entry.push(query); |
| }); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var StyleWithImports = /** @class */ (function () { |
| function StyleWithImports(style, styleUrls) { |
| this.style = style; |
| this.styleUrls = styleUrls; |
| } |
| return StyleWithImports; |
| }()); |
| function isStyleUrlResolvable(url) { |
| if (url == null || url.length === 0 || url[0] == '/') |
| return false; |
| var schemeMatch = url.match(URL_WITH_SCHEMA_REGEXP); |
| return schemeMatch === null || schemeMatch[1] == 'package' || schemeMatch[1] == 'asset'; |
| } |
| /** |
| * Rewrites stylesheets by resolving and removing the @import urls that |
| * are either relative or don't have a `package:` scheme |
| */ |
| function extractStyleUrls(resolver, baseUrl, cssText) { |
| var foundUrls = []; |
| var modifiedCssText = cssText.replace(CSS_STRIPPABLE_COMMENT_REGEXP, '') |
| .replace(CSS_IMPORT_REGEXP, function () { |
| var m = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| m[_i] = arguments[_i]; |
| } |
| var url = m[1] || m[2]; |
| if (!isStyleUrlResolvable(url)) { |
| // Do not attempt to resolve non-package absolute URLs with URI |
| // scheme |
| return m[0]; |
| } |
| foundUrls.push(resolver.resolve(baseUrl, url)); |
| return ''; |
| }); |
| return new StyleWithImports(modifiedCssText, foundUrls); |
| } |
| var CSS_IMPORT_REGEXP = /@import\s+(?:url\()?\s*(?:(?:['"]([^'"]*))|([^;\)\s]*))[^;]*;?/g; |
| var CSS_STRIPPABLE_COMMENT_REGEXP = /\/\*(?!#\s*(?:sourceURL|sourceMappingURL)=)[\s\S]+?\*\//g; |
| var URL_WITH_SCHEMA_REGEXP = /^([^:/?#]+):/; |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var PROPERTY_PARTS_SEPARATOR = '.'; |
| var ATTRIBUTE_PREFIX = 'attr'; |
| var CLASS_PREFIX = 'class'; |
| var STYLE_PREFIX = 'style'; |
| var ANIMATE_PROP_PREFIX = 'animate-'; |
| /** |
| * Parses bindings in templates and in the directive host area. |
| */ |
| var BindingParser = /** @class */ (function () { |
| function BindingParser(_exprParser, _interpolationConfig, _schemaRegistry, pipes, errors) { |
| this._exprParser = _exprParser; |
| this._interpolationConfig = _interpolationConfig; |
| this._schemaRegistry = _schemaRegistry; |
| this.errors = errors; |
| this.pipesByName = null; |
| this._usedPipes = new Map(); |
| // When the `pipes` parameter is `null`, do not check for used pipes |
| // This is used in IVY when we might not know the available pipes at compile time |
| if (pipes) { |
| var pipesByName_1 = new Map(); |
| pipes.forEach(function (pipe) { return pipesByName_1.set(pipe.name, pipe); }); |
| this.pipesByName = pipesByName_1; |
| } |
| } |
| Object.defineProperty(BindingParser.prototype, "interpolationConfig", { |
| get: function () { return this._interpolationConfig; }, |
| enumerable: true, |
| configurable: true |
| }); |
| BindingParser.prototype.getUsedPipes = function () { return Array.from(this._usedPipes.values()); }; |
| BindingParser.prototype.createBoundHostProperties = function (dirMeta, sourceSpan) { |
| var _this = this; |
| if (dirMeta.hostProperties) { |
| var boundProps_1 = []; |
| Object.keys(dirMeta.hostProperties).forEach(function (propName) { |
| var expression = dirMeta.hostProperties[propName]; |
| if (typeof expression === 'string') { |
| _this.parsePropertyBinding(propName, expression, true, sourceSpan, [], boundProps_1); |
| } |
| else { |
| _this._reportError("Value of the host property binding \"" + propName + "\" needs to be a string representing an expression but got \"" + expression + "\" (" + typeof expression + ")", sourceSpan); |
| } |
| }); |
| return boundProps_1; |
| } |
| return null; |
| }; |
| BindingParser.prototype.createDirectiveHostPropertyAsts = function (dirMeta, elementSelector, sourceSpan) { |
| var _this = this; |
| var boundProps = this.createBoundHostProperties(dirMeta, sourceSpan); |
| return boundProps && |
| boundProps.map(function (prop) { return _this.createBoundElementProperty(elementSelector, prop); }); |
| }; |
| BindingParser.prototype.createDirectiveHostEventAsts = function (dirMeta, sourceSpan) { |
| var _this = this; |
| if (dirMeta.hostListeners) { |
| var targetEvents_1 = []; |
| Object.keys(dirMeta.hostListeners).forEach(function (propName) { |
| var expression = dirMeta.hostListeners[propName]; |
| if (typeof expression === 'string') { |
| // TODO: pass a more accurate handlerSpan for this event. |
| _this.parseEvent(propName, expression, sourceSpan, sourceSpan, [], targetEvents_1); |
| } |
| else { |
| _this._reportError("Value of the host listener \"" + propName + "\" needs to be a string representing an expression but got \"" + expression + "\" (" + typeof expression + ")", sourceSpan); |
| } |
| }); |
| return targetEvents_1; |
| } |
| return null; |
| }; |
| BindingParser.prototype.parseInterpolation = function (value, sourceSpan) { |
| var sourceInfo = sourceSpan.start.toString(); |
| try { |
| var ast = this._exprParser.parseInterpolation(value, sourceInfo, this._interpolationConfig); |
| if (ast) |
| this._reportExpressionParserErrors(ast.errors, sourceSpan); |
| this._checkPipes(ast, sourceSpan); |
| return ast; |
| } |
| catch (e) { |
| this._reportError("" + e, sourceSpan); |
| return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo); |
| } |
| }; |
| // Parse an inline template binding. ie `<tag *tplKey="<tplValue>">` |
| BindingParser.prototype.parseInlineTemplateBinding = function (tplKey, tplValue, sourceSpan, targetMatchableAttrs, targetProps, targetVars) { |
| var bindings = this._parseTemplateBindings(tplKey, tplValue, sourceSpan); |
| for (var i = 0; i < bindings.length; i++) { |
| var binding = bindings[i]; |
| if (binding.keyIsVar) { |
| targetVars.push(new ParsedVariable(binding.key, binding.name, sourceSpan)); |
| } |
| else if (binding.expression) { |
| this._parsePropertyAst(binding.key, binding.expression, sourceSpan, targetMatchableAttrs, targetProps); |
| } |
| else { |
| targetMatchableAttrs.push([binding.key, '']); |
| this.parseLiteralAttr(binding.key, null, sourceSpan, targetMatchableAttrs, targetProps); |
| } |
| } |
| }; |
| BindingParser.prototype._parseTemplateBindings = function (tplKey, tplValue, sourceSpan) { |
| var _this = this; |
| var sourceInfo = sourceSpan.start.toString(); |
| try { |
| var bindingsResult = this._exprParser.parseTemplateBindings(tplKey, tplValue, sourceInfo); |
| this._reportExpressionParserErrors(bindingsResult.errors, sourceSpan); |
| bindingsResult.templateBindings.forEach(function (binding) { |
| if (binding.expression) { |
| _this._checkPipes(binding.expression, sourceSpan); |
| } |
| }); |
| bindingsResult.warnings.forEach(function (warning) { _this._reportError(warning, sourceSpan, exports.ParseErrorLevel.WARNING); }); |
| return bindingsResult.templateBindings; |
| } |
| catch (e) { |
| this._reportError("" + e, sourceSpan); |
| return []; |
| } |
| }; |
| BindingParser.prototype.parseLiteralAttr = function (name, value, sourceSpan, targetMatchableAttrs, targetProps) { |
| if (isAnimationLabel(name)) { |
| name = name.substring(1); |
| if (value) { |
| this._reportError("Assigning animation triggers via @prop=\"exp\" attributes with an expression is invalid." + |
| " Use property bindings (e.g. [@prop]=\"exp\") or use an attribute without a value (e.g. @prop) instead.", sourceSpan, exports.ParseErrorLevel.ERROR); |
| } |
| this._parseAnimation(name, value, sourceSpan, targetMatchableAttrs, targetProps); |
| } |
| else { |
| targetProps.push(new ParsedProperty(name, this._exprParser.wrapLiteralPrimitive(value, ''), exports.ParsedPropertyType.LITERAL_ATTR, sourceSpan)); |
| } |
| }; |
| BindingParser.prototype.parsePropertyBinding = function (name, expression, isHost, sourceSpan, targetMatchableAttrs, targetProps) { |
| var isAnimationProp = false; |
| if (name.startsWith(ANIMATE_PROP_PREFIX)) { |
| isAnimationProp = true; |
| name = name.substring(ANIMATE_PROP_PREFIX.length); |
| } |
| else if (isAnimationLabel(name)) { |
| isAnimationProp = true; |
| name = name.substring(1); |
| } |
| if (isAnimationProp) { |
| this._parseAnimation(name, expression, sourceSpan, targetMatchableAttrs, targetProps); |
| } |
| else { |
| this._parsePropertyAst(name, this._parseBinding(expression, isHost, sourceSpan), sourceSpan, targetMatchableAttrs, targetProps); |
| } |
| }; |
| BindingParser.prototype.parsePropertyInterpolation = function (name, value, sourceSpan, targetMatchableAttrs, targetProps) { |
| var expr = this.parseInterpolation(value, sourceSpan); |
| if (expr) { |
| this._parsePropertyAst(name, expr, sourceSpan, targetMatchableAttrs, targetProps); |
| return true; |
| } |
| return false; |
| }; |
| BindingParser.prototype._parsePropertyAst = function (name, ast, sourceSpan, targetMatchableAttrs, targetProps) { |
| targetMatchableAttrs.push([name, ast.source]); |
| targetProps.push(new ParsedProperty(name, ast, exports.ParsedPropertyType.DEFAULT, sourceSpan)); |
| }; |
| BindingParser.prototype._parseAnimation = function (name, expression, sourceSpan, targetMatchableAttrs, targetProps) { |
| // This will occur when a @trigger is not paired with an expression. |
| // For animations it is valid to not have an expression since */void |
| // states will be applied by angular when the element is attached/detached |
| var ast = this._parseBinding(expression || 'undefined', false, sourceSpan); |
| targetMatchableAttrs.push([name, ast.source]); |
| targetProps.push(new ParsedProperty(name, ast, exports.ParsedPropertyType.ANIMATION, sourceSpan)); |
| }; |
| BindingParser.prototype._parseBinding = function (value, isHostBinding, sourceSpan) { |
| var sourceInfo = (sourceSpan && sourceSpan.start || '(unknown)').toString(); |
| try { |
| var ast = isHostBinding ? |
| this._exprParser.parseSimpleBinding(value, sourceInfo, this._interpolationConfig) : |
| this._exprParser.parseBinding(value, sourceInfo, this._interpolationConfig); |
| if (ast) |
| this._reportExpressionParserErrors(ast.errors, sourceSpan); |
| this._checkPipes(ast, sourceSpan); |
| return ast; |
| } |
| catch (e) { |
| this._reportError("" + e, sourceSpan); |
| return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo); |
| } |
| }; |
| BindingParser.prototype.createBoundElementProperty = function (elementSelector, boundProp, skipValidation, mapPropertyName) { |
| if (skipValidation === void 0) { skipValidation = false; } |
| if (mapPropertyName === void 0) { mapPropertyName = true; } |
| if (boundProp.isAnimation) { |
| return new BoundElementProperty(boundProp.name, 4 /* Animation */, SecurityContext.NONE, boundProp.expression, null, boundProp.sourceSpan); |
| } |
| var unit = null; |
| var bindingType = undefined; |
| var boundPropertyName = null; |
| var parts = boundProp.name.split(PROPERTY_PARTS_SEPARATOR); |
| var securityContexts = undefined; |
| // Check for special cases (prefix style, attr, class) |
| if (parts.length > 1) { |
| if (parts[0] == ATTRIBUTE_PREFIX) { |
| boundPropertyName = parts[1]; |
| if (!skipValidation) { |
| this._validatePropertyOrAttributeName(boundPropertyName, boundProp.sourceSpan, true); |
| } |
| securityContexts = calcPossibleSecurityContexts(this._schemaRegistry, elementSelector, boundPropertyName, true); |
| var nsSeparatorIdx = boundPropertyName.indexOf(':'); |
| if (nsSeparatorIdx > -1) { |
| var ns = boundPropertyName.substring(0, nsSeparatorIdx); |
| var name_1 = boundPropertyName.substring(nsSeparatorIdx + 1); |
| boundPropertyName = mergeNsAndName(ns, name_1); |
| } |
| bindingType = 1 /* Attribute */; |
| } |
| else if (parts[0] == CLASS_PREFIX) { |
| boundPropertyName = parts[1]; |
| bindingType = 2 /* Class */; |
| securityContexts = [SecurityContext.NONE]; |
| } |
| else if (parts[0] == STYLE_PREFIX) { |
| unit = parts.length > 2 ? parts[2] : null; |
| boundPropertyName = parts[1]; |
| bindingType = 3 /* Style */; |
| securityContexts = [SecurityContext.STYLE]; |
| } |
| } |
| // If not a special case, use the full property name |
| if (boundPropertyName === null) { |
| var mappedPropName = this._schemaRegistry.getMappedPropName(boundProp.name); |
| boundPropertyName = mapPropertyName ? mappedPropName : boundProp.name; |
| securityContexts = calcPossibleSecurityContexts(this._schemaRegistry, elementSelector, mappedPropName, false); |
| bindingType = 0 /* Property */; |
| if (!skipValidation) { |
| this._validatePropertyOrAttributeName(mappedPropName, boundProp.sourceSpan, false); |
| } |
| } |
| return new BoundElementProperty(boundPropertyName, bindingType, securityContexts[0], boundProp.expression, unit, boundProp.sourceSpan); |
| }; |
| BindingParser.prototype.parseEvent = function (name, expression, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents) { |
| if (isAnimationLabel(name)) { |
| name = name.substr(1); |
| this._parseAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents); |
| } |
| else { |
| this._parseRegularEvent(name, expression, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents); |
| } |
| }; |
| BindingParser.prototype.calcPossibleSecurityContexts = function (selector, propName, isAttribute) { |
| var prop = this._schemaRegistry.getMappedPropName(propName); |
| return calcPossibleSecurityContexts(this._schemaRegistry, selector, prop, isAttribute); |
| }; |
| BindingParser.prototype._parseAnimationEvent = function (name, expression, sourceSpan, handlerSpan, targetEvents) { |
| var matches = splitAtPeriod(name, [name, '']); |
| var eventName = matches[0]; |
| var phase = matches[1].toLowerCase(); |
| if (phase) { |
| switch (phase) { |
| case 'start': |
| case 'done': |
| var ast = this._parseAction(expression, handlerSpan); |
| targetEvents.push(new ParsedEvent(eventName, phase, 1 /* Animation */, ast, sourceSpan, handlerSpan)); |
| break; |
| default: |
| this._reportError("The provided animation output phase value \"" + phase + "\" for \"@" + eventName + "\" is not supported (use start or done)", sourceSpan); |
| break; |
| } |
| } |
| else { |
| this._reportError("The animation trigger output event (@" + eventName + ") is missing its phase value name (start or done are currently supported)", sourceSpan); |
| } |
| }; |
| BindingParser.prototype._parseRegularEvent = function (name, expression, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents) { |
| // long format: 'target: eventName' |
| var _a = __read(splitAtColon(name, [null, name]), 2), target = _a[0], eventName = _a[1]; |
| var ast = this._parseAction(expression, handlerSpan); |
| targetMatchableAttrs.push([name, ast.source]); |
| targetEvents.push(new ParsedEvent(eventName, target, 0 /* Regular */, ast, sourceSpan, handlerSpan)); |
| // Don't detect directives for event names for now, |
| // so don't add the event name to the matchableAttrs |
| }; |
| BindingParser.prototype._parseAction = function (value, sourceSpan) { |
| var sourceInfo = (sourceSpan && sourceSpan.start || '(unknown').toString(); |
| try { |
| var ast = this._exprParser.parseAction(value, sourceInfo, this._interpolationConfig); |
| if (ast) { |
| this._reportExpressionParserErrors(ast.errors, sourceSpan); |
| } |
| if (!ast || ast.ast instanceof EmptyExpr) { |
| this._reportError("Empty expressions are not allowed", sourceSpan); |
| return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo); |
| } |
| this._checkPipes(ast, sourceSpan); |
| return ast; |
| } |
| catch (e) { |
| this._reportError("" + e, sourceSpan); |
| return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo); |
| } |
| }; |
| BindingParser.prototype._reportError = function (message, sourceSpan, level) { |
| if (level === void 0) { level = exports.ParseErrorLevel.ERROR; } |
| this.errors.push(new ParseError(sourceSpan, message, level)); |
| }; |
| BindingParser.prototype._reportExpressionParserErrors = function (errors, sourceSpan) { |
| var e_1, _a; |
| try { |
| for (var errors_1 = __values(errors), errors_1_1 = errors_1.next(); !errors_1_1.done; errors_1_1 = errors_1.next()) { |
| var error = errors_1_1.value; |
| this._reportError(error.message, sourceSpan); |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (errors_1_1 && !errors_1_1.done && (_a = errors_1.return)) _a.call(errors_1); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| }; |
| // Make sure all the used pipes are known in `this.pipesByName` |
| BindingParser.prototype._checkPipes = function (ast, sourceSpan) { |
| var _this = this; |
| if (ast && this.pipesByName) { |
| var collector = new PipeCollector(); |
| ast.visit(collector); |
| collector.pipes.forEach(function (ast, pipeName) { |
| var pipeMeta = _this.pipesByName.get(pipeName); |
| if (!pipeMeta) { |
| _this._reportError("The pipe '" + pipeName + "' could not be found", new ParseSourceSpan(sourceSpan.start.moveBy(ast.span.start), sourceSpan.start.moveBy(ast.span.end))); |
| } |
| else { |
| _this._usedPipes.set(pipeName, pipeMeta); |
| } |
| }); |
| } |
| }; |
| /** |
| * @param propName the name of the property / attribute |
| * @param sourceSpan |
| * @param isAttr true when binding to an attribute |
| */ |
| BindingParser.prototype._validatePropertyOrAttributeName = function (propName, sourceSpan, isAttr) { |
| var report = isAttr ? this._schemaRegistry.validateAttribute(propName) : |
| this._schemaRegistry.validateProperty(propName); |
| if (report.error) { |
| this._reportError(report.msg, sourceSpan, exports.ParseErrorLevel.ERROR); |
| } |
| }; |
| return BindingParser; |
| }()); |
| var PipeCollector = /** @class */ (function (_super) { |
| __extends(PipeCollector, _super); |
| function PipeCollector() { |
| var _this = _super !== null && _super.apply(this, arguments) || this; |
| _this.pipes = new Map(); |
| return _this; |
| } |
| PipeCollector.prototype.visitPipe = function (ast, context) { |
| this.pipes.set(ast.name, ast); |
| ast.exp.visit(this); |
| this.visitAll(ast.args, context); |
| return null; |
| }; |
| return PipeCollector; |
| }(RecursiveAstVisitor$1)); |
| function isAnimationLabel(name) { |
| return name[0] == '@'; |
| } |
| function calcPossibleSecurityContexts(registry, selector, propName, isAttribute) { |
| var ctxs = []; |
| CssSelector.parse(selector).forEach(function (selector) { |
| var elementNames = selector.element ? [selector.element] : registry.allKnownElementNames(); |
| var notElementNames = new Set(selector.notSelectors.filter(function (selector) { return selector.isElementSelector(); }) |
| .map(function (selector) { return selector.element; })); |
| var possibleElementNames = elementNames.filter(function (elementName) { return !notElementNames.has(elementName); }); |
| ctxs.push.apply(ctxs, __spread(possibleElementNames.map(function (elementName) { return registry.securityContext(elementName, propName, isAttribute); }))); |
| }); |
| return ctxs.length === 0 ? [SecurityContext.NONE] : Array.from(new Set(ctxs)).sort(); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var NG_CONTENT_SELECT_ATTR = 'select'; |
| var LINK_ELEMENT = 'link'; |
| var LINK_STYLE_REL_ATTR = 'rel'; |
| var LINK_STYLE_HREF_ATTR = 'href'; |
| var LINK_STYLE_REL_VALUE = 'stylesheet'; |
| var STYLE_ELEMENT = 'style'; |
| var SCRIPT_ELEMENT = 'script'; |
| var NG_NON_BINDABLE_ATTR = 'ngNonBindable'; |
| var NG_PROJECT_AS = 'ngProjectAs'; |
| function preparseElement(ast) { |
| var selectAttr = null; |
| var hrefAttr = null; |
| var relAttr = null; |
| var nonBindable = false; |
| var projectAs = ''; |
| ast.attrs.forEach(function (attr) { |
| var lcAttrName = attr.name.toLowerCase(); |
| if (lcAttrName == NG_CONTENT_SELECT_ATTR) { |
| selectAttr = attr.value; |
| } |
| else if (lcAttrName == LINK_STYLE_HREF_ATTR) { |
| hrefAttr = attr.value; |
| } |
| else if (lcAttrName == LINK_STYLE_REL_ATTR) { |
| relAttr = attr.value; |
| } |
| else if (attr.name == NG_NON_BINDABLE_ATTR) { |
| nonBindable = true; |
| } |
| else if (attr.name == NG_PROJECT_AS) { |
| if (attr.value.length > 0) { |
| projectAs = attr.value; |
| } |
| } |
| }); |
| selectAttr = normalizeNgContentSelect(selectAttr); |
| var nodeName = ast.name.toLowerCase(); |
| var type = PreparsedElementType.OTHER; |
| if (isNgContent(nodeName)) { |
| type = PreparsedElementType.NG_CONTENT; |
| } |
| else if (nodeName == STYLE_ELEMENT) { |
| type = PreparsedElementType.STYLE; |
| } |
| else if (nodeName == SCRIPT_ELEMENT) { |
| type = PreparsedElementType.SCRIPT; |
| } |
| else if (nodeName == LINK_ELEMENT && relAttr == LINK_STYLE_REL_VALUE) { |
| type = PreparsedElementType.STYLESHEET; |
| } |
| return new PreparsedElement(type, selectAttr, hrefAttr, nonBindable, projectAs); |
| } |
| var PreparsedElementType; |
| (function (PreparsedElementType) { |
| PreparsedElementType[PreparsedElementType["NG_CONTENT"] = 0] = "NG_CONTENT"; |
| PreparsedElementType[PreparsedElementType["STYLE"] = 1] = "STYLE"; |
| PreparsedElementType[PreparsedElementType["STYLESHEET"] = 2] = "STYLESHEET"; |
| PreparsedElementType[PreparsedElementType["SCRIPT"] = 3] = "SCRIPT"; |
| PreparsedElementType[PreparsedElementType["OTHER"] = 4] = "OTHER"; |
| })(PreparsedElementType || (PreparsedElementType = {})); |
| var PreparsedElement = /** @class */ (function () { |
| function PreparsedElement(type, selectAttr, hrefAttr, nonBindable, projectAs) { |
| this.type = type; |
| this.selectAttr = selectAttr; |
| this.hrefAttr = hrefAttr; |
| this.nonBindable = nonBindable; |
| this.projectAs = projectAs; |
| } |
| return PreparsedElement; |
| }()); |
| function normalizeNgContentSelect(selectAttr) { |
| if (selectAttr === null || selectAttr.length === 0) { |
| return '*'; |
| } |
| return selectAttr; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var BIND_NAME_REGEXP = /^(?:(?:(?:(bind-)|(let-)|(ref-|#)|(on-)|(bindon-)|(@))(.+))|\[\(([^\)]+)\)\]|\[([^\]]+)\]|\(([^\)]+)\))$/; |
| // Group 1 = "bind-" |
| var KW_BIND_IDX = 1; |
| // Group 2 = "let-" |
| var KW_LET_IDX = 2; |
| // Group 3 = "ref-/#" |
| var KW_REF_IDX = 3; |
| // Group 4 = "on-" |
| var KW_ON_IDX = 4; |
| // Group 5 = "bindon-" |
| var KW_BINDON_IDX = 5; |
| // Group 6 = "@" |
| var KW_AT_IDX = 6; |
| // Group 7 = the identifier after "bind-", "let-", "ref-/#", "on-", "bindon-" or "@" |
| var IDENT_KW_IDX = 7; |
| // Group 8 = identifier inside [()] |
| var IDENT_BANANA_BOX_IDX = 8; |
| // Group 9 = identifier inside [] |
| var IDENT_PROPERTY_IDX = 9; |
| // Group 10 = identifier inside () |
| var IDENT_EVENT_IDX = 10; |
| var TEMPLATE_ATTR_PREFIX = '*'; |
| var CLASS_ATTR = 'class'; |
| var _TEXT_CSS_SELECTOR; |
| function TEXT_CSS_SELECTOR() { |
| if (!_TEXT_CSS_SELECTOR) { |
| _TEXT_CSS_SELECTOR = CssSelector.parse('*')[0]; |
| } |
| return _TEXT_CSS_SELECTOR; |
| } |
| var TemplateParseError = /** @class */ (function (_super) { |
| __extends(TemplateParseError, _super); |
| function TemplateParseError(message, span, level) { |
| return _super.call(this, span, message, level) || this; |
| } |
| return TemplateParseError; |
| }(ParseError)); |
| var TemplateParseResult = /** @class */ (function () { |
| function TemplateParseResult(templateAst, usedPipes, errors) { |
| this.templateAst = templateAst; |
| this.usedPipes = usedPipes; |
| this.errors = errors; |
| } |
| return TemplateParseResult; |
| }()); |
| var TemplateParser = /** @class */ (function () { |
| function TemplateParser(_config, _reflector, _exprParser, _schemaRegistry, _htmlParser, _console, transforms) { |
| this._config = _config; |
| this._reflector = _reflector; |
| this._exprParser = _exprParser; |
| this._schemaRegistry = _schemaRegistry; |
| this._htmlParser = _htmlParser; |
| this._console = _console; |
| this.transforms = transforms; |
| } |
| Object.defineProperty(TemplateParser.prototype, "expressionParser", { |
| get: function () { return this._exprParser; }, |
| enumerable: true, |
| configurable: true |
| }); |
| TemplateParser.prototype.parse = function (component, template, directives, pipes, schemas, templateUrl, preserveWhitespaces) { |
| var result = this.tryParse(component, template, directives, pipes, schemas, templateUrl, preserveWhitespaces); |
| var warnings = result.errors.filter(function (error) { return error.level === exports.ParseErrorLevel.WARNING; }); |
| var errors = result.errors.filter(function (error) { return error.level === exports.ParseErrorLevel.ERROR; }); |
| if (warnings.length > 0) { |
| this._console.warn("Template parse warnings:\n" + warnings.join('\n')); |
| } |
| if (errors.length > 0) { |
| var errorString = errors.join('\n'); |
| throw syntaxError("Template parse errors:\n" + errorString, errors); |
| } |
| return { template: result.templateAst, pipes: result.usedPipes }; |
| }; |
| TemplateParser.prototype.tryParse = function (component, template, directives, pipes, schemas, templateUrl, preserveWhitespaces) { |
| var htmlParseResult = typeof template === 'string' ? |
| this._htmlParser.parse(template, templateUrl, { |
| tokenizeExpansionForms: true, |
| interpolationConfig: this.getInterpolationConfig(component) |
| }) : |
| template; |
| if (!preserveWhitespaces) { |
| htmlParseResult = removeWhitespaces(htmlParseResult); |
| } |
| return this.tryParseHtml(this.expandHtml(htmlParseResult), component, directives, pipes, schemas); |
| }; |
| TemplateParser.prototype.tryParseHtml = function (htmlAstWithErrors, component, directives, pipes, schemas) { |
| var result; |
| var errors = htmlAstWithErrors.errors; |
| var usedPipes = []; |
| if (htmlAstWithErrors.rootNodes.length > 0) { |
| var uniqDirectives = removeSummaryDuplicates(directives); |
| var uniqPipes = removeSummaryDuplicates(pipes); |
| var providerViewContext = new ProviderViewContext(this._reflector, component); |
| var interpolationConfig = undefined; |
| if (component.template && component.template.interpolation) { |
| interpolationConfig = { |
| start: component.template.interpolation[0], |
| end: component.template.interpolation[1] |
| }; |
| } |
| var bindingParser = new BindingParser(this._exprParser, interpolationConfig, this._schemaRegistry, uniqPipes, errors); |
| var parseVisitor = new TemplateParseVisitor(this._reflector, this._config, providerViewContext, uniqDirectives, bindingParser, this._schemaRegistry, schemas, errors); |
| result = visitAll$1(parseVisitor, htmlAstWithErrors.rootNodes, EMPTY_ELEMENT_CONTEXT); |
| errors.push.apply(errors, __spread(providerViewContext.errors)); |
| usedPipes.push.apply(usedPipes, __spread(bindingParser.getUsedPipes())); |
| } |
| else { |
| result = []; |
| } |
| this._assertNoReferenceDuplicationOnTemplate(result, errors); |
| if (errors.length > 0) { |
| return new TemplateParseResult(result, usedPipes, errors); |
| } |
| if (this.transforms) { |
| this.transforms.forEach(function (transform) { result = templateVisitAll(transform, result); }); |
| } |
| return new TemplateParseResult(result, usedPipes, errors); |
| }; |
| TemplateParser.prototype.expandHtml = function (htmlAstWithErrors, forced) { |
| if (forced === void 0) { forced = false; } |
| var errors = htmlAstWithErrors.errors; |
| if (errors.length == 0 || forced) { |
| // Transform ICU messages to angular directives |
| var expandedHtmlAst = expandNodes(htmlAstWithErrors.rootNodes); |
| errors.push.apply(errors, __spread(expandedHtmlAst.errors)); |
| htmlAstWithErrors = new ParseTreeResult(expandedHtmlAst.nodes, errors); |
| } |
| return htmlAstWithErrors; |
| }; |
| TemplateParser.prototype.getInterpolationConfig = function (component) { |
| if (component.template) { |
| return InterpolationConfig.fromArray(component.template.interpolation); |
| } |
| return undefined; |
| }; |
| /** @internal */ |
| TemplateParser.prototype._assertNoReferenceDuplicationOnTemplate = function (result, errors) { |
| var existingReferences = []; |
| result.filter(function (element) { return !!element.references; }) |
| .forEach(function (element) { return element.references.forEach(function (reference) { |
| var name = reference.name; |
| if (existingReferences.indexOf(name) < 0) { |
| existingReferences.push(name); |
| } |
| else { |
| var error = new TemplateParseError("Reference \"#" + name + "\" is defined several times", reference.sourceSpan, exports.ParseErrorLevel.ERROR); |
| errors.push(error); |
| } |
| }); }); |
| }; |
| return TemplateParser; |
| }()); |
| var TemplateParseVisitor = /** @class */ (function () { |
| function TemplateParseVisitor(reflector, config, providerViewContext, directives, _bindingParser, _schemaRegistry, _schemas, _targetErrors) { |
| var _this = this; |
| this.reflector = reflector; |
| this.config = config; |
| this.providerViewContext = providerViewContext; |
| this._bindingParser = _bindingParser; |
| this._schemaRegistry = _schemaRegistry; |
| this._schemas = _schemas; |
| this._targetErrors = _targetErrors; |
| this.selectorMatcher = new SelectorMatcher(); |
| this.directivesIndex = new Map(); |
| this.ngContentCount = 0; |
| // Note: queries start with id 1 so we can use the number in a Bloom filter! |
| this.contentQueryStartId = providerViewContext.component.viewQueries.length + 1; |
| directives.forEach(function (directive, index) { |
| var selector = CssSelector.parse(directive.selector); |
| _this.selectorMatcher.addSelectables(selector, directive); |
| _this.directivesIndex.set(directive, index); |
| }); |
| } |
| TemplateParseVisitor.prototype.visitExpansion = function (expansion, context) { return null; }; |
| TemplateParseVisitor.prototype.visitExpansionCase = function (expansionCase, context) { return null; }; |
| TemplateParseVisitor.prototype.visitText = function (text, parent) { |
| var ngContentIndex = parent.findNgContentIndex(TEXT_CSS_SELECTOR()); |
| var valueNoNgsp = replaceNgsp(text.value); |
| var expr = this._bindingParser.parseInterpolation(valueNoNgsp, text.sourceSpan); |
| return expr ? new BoundTextAst(expr, ngContentIndex, text.sourceSpan) : |
| new TextAst(valueNoNgsp, ngContentIndex, text.sourceSpan); |
| }; |
| TemplateParseVisitor.prototype.visitAttribute = function (attribute, context) { |
| return new AttrAst(attribute.name, attribute.value, attribute.sourceSpan); |
| }; |
| TemplateParseVisitor.prototype.visitComment = function (comment, context) { return null; }; |
| TemplateParseVisitor.prototype.visitElement = function (element, parent) { |
| var _this = this; |
| var queryStartIndex = this.contentQueryStartId; |
| var elName = element.name; |
| var preparsedElement = preparseElement(element); |
| if (preparsedElement.type === PreparsedElementType.SCRIPT || |
| preparsedElement.type === PreparsedElementType.STYLE) { |
| // Skipping <script> for security reasons |
| // Skipping <style> as we already processed them |
| // in the StyleCompiler |
| return null; |
| } |
| if (preparsedElement.type === PreparsedElementType.STYLESHEET && |
| isStyleUrlResolvable(preparsedElement.hrefAttr)) { |
| // Skipping stylesheets with either relative urls or package scheme as we already processed |
| // them in the StyleCompiler |
| return null; |
| } |
| var matchableAttrs = []; |
| var elementOrDirectiveProps = []; |
| var elementOrDirectiveRefs = []; |
| var elementVars = []; |
| var events = []; |
| var templateElementOrDirectiveProps = []; |
| var templateMatchableAttrs = []; |
| var templateElementVars = []; |
| var hasInlineTemplates = false; |
| var attrs = []; |
| var isTemplateElement = isNgTemplate(element.name); |
| element.attrs.forEach(function (attr) { |
| var parsedVariables = []; |
| var hasBinding = _this._parseAttr(isTemplateElement, attr, matchableAttrs, elementOrDirectiveProps, events, elementOrDirectiveRefs, elementVars); |
| elementVars.push.apply(elementVars, __spread(parsedVariables.map(function (v) { return VariableAst.fromParsedVariable(v); }))); |
| var templateValue; |
| var templateKey; |
| var normalizedName = _this._normalizeAttributeName(attr.name); |
| if (normalizedName.startsWith(TEMPLATE_ATTR_PREFIX)) { |
| templateValue = attr.value; |
| templateKey = normalizedName.substring(TEMPLATE_ATTR_PREFIX.length); |
| } |
| var hasTemplateBinding = templateValue != null; |
| if (hasTemplateBinding) { |
| if (hasInlineTemplates) { |
| _this._reportError("Can't have multiple template bindings on one element. Use only one attribute prefixed with *", attr.sourceSpan); |
| } |
| hasInlineTemplates = true; |
| var parsedVariables_1 = []; |
| _this._bindingParser.parseInlineTemplateBinding(templateKey, templateValue, attr.sourceSpan, templateMatchableAttrs, templateElementOrDirectiveProps, parsedVariables_1); |
| templateElementVars.push.apply(templateElementVars, __spread(parsedVariables_1.map(function (v) { return VariableAst.fromParsedVariable(v); }))); |
| } |
| if (!hasBinding && !hasTemplateBinding) { |
| // don't include the bindings as attributes as well in the AST |
| attrs.push(_this.visitAttribute(attr, null)); |
| matchableAttrs.push([attr.name, attr.value]); |
| } |
| }); |
| var elementCssSelector = createElementCssSelector(elName, matchableAttrs); |
| var _a = this._parseDirectives(this.selectorMatcher, elementCssSelector), directiveMetas = _a.directives, matchElement = _a.matchElement; |
| var references = []; |
| var boundDirectivePropNames = new Set(); |
| var directiveAsts = this._createDirectiveAsts(isTemplateElement, element.name, directiveMetas, elementOrDirectiveProps, elementOrDirectiveRefs, element.sourceSpan, references, boundDirectivePropNames); |
| var elementProps = this._createElementPropertyAsts(element.name, elementOrDirectiveProps, boundDirectivePropNames); |
| var isViewRoot = parent.isTemplateElement || hasInlineTemplates; |
| var providerContext = new ProviderElementContext(this.providerViewContext, parent.providerContext, isViewRoot, directiveAsts, attrs, references, isTemplateElement, queryStartIndex, element.sourceSpan); |
| var children = visitAll$1(preparsedElement.nonBindable ? NON_BINDABLE_VISITOR : this, element.children, ElementContext.create(isTemplateElement, directiveAsts, isTemplateElement ? parent.providerContext : providerContext)); |
| providerContext.afterElement(); |
| // Override the actual selector when the `ngProjectAs` attribute is provided |
| var projectionSelector = preparsedElement.projectAs != '' ? |
| CssSelector.parse(preparsedElement.projectAs)[0] : |
| elementCssSelector; |
| var ngContentIndex = parent.findNgContentIndex(projectionSelector); |
| var parsedElement; |
| if (preparsedElement.type === PreparsedElementType.NG_CONTENT) { |
| // `<ng-content>` element |
| if (element.children && !element.children.every(_isEmptyTextNode)) { |
| this._reportError("<ng-content> element cannot have content.", element.sourceSpan); |
| } |
| parsedElement = new NgContentAst(this.ngContentCount++, hasInlineTemplates ? null : ngContentIndex, element.sourceSpan); |
| } |
| else if (isTemplateElement) { |
| // `<ng-template>` element |
| this._assertAllEventsPublishedByDirectives(directiveAsts, events); |
| this._assertNoComponentsNorElementBindingsOnTemplate(directiveAsts, elementProps, element.sourceSpan); |
| parsedElement = new EmbeddedTemplateAst(attrs, events, references, elementVars, providerContext.transformedDirectiveAsts, providerContext.transformProviders, providerContext.transformedHasViewContainer, providerContext.queryMatches, children, hasInlineTemplates ? null : ngContentIndex, element.sourceSpan); |
| } |
| else { |
| // element other than `<ng-content>` and `<ng-template>` |
| this._assertElementExists(matchElement, element); |
| this._assertOnlyOneComponent(directiveAsts, element.sourceSpan); |
| var ngContentIndex_1 = hasInlineTemplates ? null : parent.findNgContentIndex(projectionSelector); |
| parsedElement = new ElementAst(elName, attrs, elementProps, events, references, providerContext.transformedDirectiveAsts, providerContext.transformProviders, providerContext.transformedHasViewContainer, providerContext.queryMatches, children, hasInlineTemplates ? null : ngContentIndex_1, element.sourceSpan, element.endSourceSpan || null); |
| } |
| if (hasInlineTemplates) { |
| // The element as a *-attribute |
| var templateQueryStartIndex = this.contentQueryStartId; |
| var templateSelector = createElementCssSelector('ng-template', templateMatchableAttrs); |
| var directives = this._parseDirectives(this.selectorMatcher, templateSelector).directives; |
| var templateBoundDirectivePropNames = new Set(); |
| var templateDirectiveAsts = this._createDirectiveAsts(true, elName, directives, templateElementOrDirectiveProps, [], element.sourceSpan, [], templateBoundDirectivePropNames); |
| var templateElementProps = this._createElementPropertyAsts(elName, templateElementOrDirectiveProps, templateBoundDirectivePropNames); |
| this._assertNoComponentsNorElementBindingsOnTemplate(templateDirectiveAsts, templateElementProps, element.sourceSpan); |
| var templateProviderContext = new ProviderElementContext(this.providerViewContext, parent.providerContext, parent.isTemplateElement, templateDirectiveAsts, [], [], true, templateQueryStartIndex, element.sourceSpan); |
| templateProviderContext.afterElement(); |
| parsedElement = new EmbeddedTemplateAst([], [], [], templateElementVars, templateProviderContext.transformedDirectiveAsts, templateProviderContext.transformProviders, templateProviderContext.transformedHasViewContainer, templateProviderContext.queryMatches, [parsedElement], ngContentIndex, element.sourceSpan); |
| } |
| return parsedElement; |
| }; |
| TemplateParseVisitor.prototype._parseAttr = function (isTemplateElement, attr, targetMatchableAttrs, targetProps, targetEvents, targetRefs, targetVars) { |
| var name = this._normalizeAttributeName(attr.name); |
| var value = attr.value; |
| var srcSpan = attr.sourceSpan; |
| var boundEvents = []; |
| var bindParts = name.match(BIND_NAME_REGEXP); |
| var hasBinding = false; |
| if (bindParts !== null) { |
| hasBinding = true; |
| if (bindParts[KW_BIND_IDX] != null) { |
| this._bindingParser.parsePropertyBinding(bindParts[IDENT_KW_IDX], value, false, srcSpan, targetMatchableAttrs, targetProps); |
| } |
| else if (bindParts[KW_LET_IDX]) { |
| if (isTemplateElement) { |
| var identifier = bindParts[IDENT_KW_IDX]; |
| this._parseVariable(identifier, value, srcSpan, targetVars); |
| } |
| else { |
| this._reportError("\"let-\" is only supported on ng-template elements.", srcSpan); |
| } |
| } |
| else if (bindParts[KW_REF_IDX]) { |
| var identifier = bindParts[IDENT_KW_IDX]; |
| this._parseReference(identifier, value, srcSpan, targetRefs); |
| } |
| else if (bindParts[KW_ON_IDX]) { |
| this._bindingParser.parseEvent(bindParts[IDENT_KW_IDX], value, srcSpan, attr.valueSpan || srcSpan, targetMatchableAttrs, boundEvents); |
| } |
| else if (bindParts[KW_BINDON_IDX]) { |
| this._bindingParser.parsePropertyBinding(bindParts[IDENT_KW_IDX], value, false, srcSpan, targetMatchableAttrs, targetProps); |
| this._parseAssignmentEvent(bindParts[IDENT_KW_IDX], value, srcSpan, attr.valueSpan || srcSpan, targetMatchableAttrs, boundEvents); |
| } |
| else if (bindParts[KW_AT_IDX]) { |
| this._bindingParser.parseLiteralAttr(name, value, srcSpan, targetMatchableAttrs, targetProps); |
| } |
| else if (bindParts[IDENT_BANANA_BOX_IDX]) { |
| this._bindingParser.parsePropertyBinding(bindParts[IDENT_BANANA_BOX_IDX], value, false, srcSpan, targetMatchableAttrs, targetProps); |
| this._parseAssignmentEvent(bindParts[IDENT_BANANA_BOX_IDX], value, srcSpan, attr.valueSpan || srcSpan, targetMatchableAttrs, boundEvents); |
| } |
| else if (bindParts[IDENT_PROPERTY_IDX]) { |
| this._bindingParser.parsePropertyBinding(bindParts[IDENT_PROPERTY_IDX], value, false, srcSpan, targetMatchableAttrs, targetProps); |
| } |
| else if (bindParts[IDENT_EVENT_IDX]) { |
| this._bindingParser.parseEvent(bindParts[IDENT_EVENT_IDX], value, srcSpan, attr.valueSpan || srcSpan, targetMatchableAttrs, boundEvents); |
| } |
| } |
| else { |
| hasBinding = this._bindingParser.parsePropertyInterpolation(name, value, srcSpan, targetMatchableAttrs, targetProps); |
| } |
| if (!hasBinding) { |
| this._bindingParser.parseLiteralAttr(name, value, srcSpan, targetMatchableAttrs, targetProps); |
| } |
| targetEvents.push.apply(targetEvents, __spread(boundEvents.map(function (e) { return BoundEventAst.fromParsedEvent(e); }))); |
| return hasBinding; |
| }; |
| TemplateParseVisitor.prototype._normalizeAttributeName = function (attrName) { |
| return /^data-/i.test(attrName) ? attrName.substring(5) : attrName; |
| }; |
| TemplateParseVisitor.prototype._parseVariable = function (identifier, value, sourceSpan, targetVars) { |
| if (identifier.indexOf('-') > -1) { |
| this._reportError("\"-\" is not allowed in variable names", sourceSpan); |
| } |
| targetVars.push(new VariableAst(identifier, value, sourceSpan)); |
| }; |
| TemplateParseVisitor.prototype._parseReference = function (identifier, value, sourceSpan, targetRefs) { |
| if (identifier.indexOf('-') > -1) { |
| this._reportError("\"-\" is not allowed in reference names", sourceSpan); |
| } |
| targetRefs.push(new ElementOrDirectiveRef(identifier, value, sourceSpan)); |
| }; |
| TemplateParseVisitor.prototype._parseAssignmentEvent = function (name, expression, sourceSpan, valueSpan, targetMatchableAttrs, targetEvents) { |
| this._bindingParser.parseEvent(name + "Change", expression + "=$event", sourceSpan, valueSpan, targetMatchableAttrs, targetEvents); |
| }; |
| TemplateParseVisitor.prototype._parseDirectives = function (selectorMatcher, elementCssSelector) { |
| var _this = this; |
| // Need to sort the directives so that we get consistent results throughout, |
| // as selectorMatcher uses Maps inside. |
| // Also deduplicate directives as they might match more than one time! |
| var directives = new Array(this.directivesIndex.size); |
| // Whether any directive selector matches on the element name |
| var matchElement = false; |
| selectorMatcher.match(elementCssSelector, function (selector, directive) { |
| directives[_this.directivesIndex.get(directive)] = directive; |
| matchElement = matchElement || selector.hasElementSelector(); |
| }); |
| return { |
| directives: directives.filter(function (dir) { return !!dir; }), |
| matchElement: matchElement, |
| }; |
| }; |
| TemplateParseVisitor.prototype._createDirectiveAsts = function (isTemplateElement, elementName, directives, props, elementOrDirectiveRefs, elementSourceSpan, targetReferences, targetBoundDirectivePropNames) { |
| var _this = this; |
| var matchedReferences = new Set(); |
| var component = null; |
| var directiveAsts = directives.map(function (directive) { |
| var sourceSpan = new ParseSourceSpan(elementSourceSpan.start, elementSourceSpan.end, "Directive " + identifierName(directive.type)); |
| if (directive.isComponent) { |
| component = directive; |
| } |
| var directiveProperties = []; |
| var boundProperties = _this._bindingParser.createDirectiveHostPropertyAsts(directive, elementName, sourceSpan); |
| var hostProperties = boundProperties.map(function (prop) { return BoundElementPropertyAst.fromBoundProperty(prop); }); |
| // Note: We need to check the host properties here as well, |
| // as we don't know the element name in the DirectiveWrapperCompiler yet. |
| hostProperties = _this._checkPropertiesInSchema(elementName, hostProperties); |
| var parsedEvents = _this._bindingParser.createDirectiveHostEventAsts(directive, sourceSpan); |
| _this._createDirectivePropertyAsts(directive.inputs, props, directiveProperties, targetBoundDirectivePropNames); |
| elementOrDirectiveRefs.forEach(function (elOrDirRef) { |
| if ((elOrDirRef.value.length === 0 && directive.isComponent) || |
| (elOrDirRef.isReferenceToDirective(directive))) { |
| targetReferences.push(new ReferenceAst(elOrDirRef.name, createTokenForReference(directive.type.reference), elOrDirRef.value, elOrDirRef.sourceSpan)); |
| matchedReferences.add(elOrDirRef.name); |
| } |
| }); |
| var hostEvents = parsedEvents.map(function (e) { return BoundEventAst.fromParsedEvent(e); }); |
| var contentQueryStartId = _this.contentQueryStartId; |
| _this.contentQueryStartId += directive.queries.length; |
| return new DirectiveAst(directive, directiveProperties, hostProperties, hostEvents, contentQueryStartId, sourceSpan); |
| }); |
| elementOrDirectiveRefs.forEach(function (elOrDirRef) { |
| if (elOrDirRef.value.length > 0) { |
| if (!matchedReferences.has(elOrDirRef.name)) { |
| _this._reportError("There is no directive with \"exportAs\" set to \"" + elOrDirRef.value + "\"", elOrDirRef.sourceSpan); |
| } |
| } |
| else if (!component) { |
| var refToken = null; |
| if (isTemplateElement) { |
| refToken = createTokenForExternalReference(_this.reflector, Identifiers.TemplateRef); |
| } |
| targetReferences.push(new ReferenceAst(elOrDirRef.name, refToken, elOrDirRef.value, elOrDirRef.sourceSpan)); |
| } |
| }); |
| return directiveAsts; |
| }; |
| TemplateParseVisitor.prototype._createDirectivePropertyAsts = function (directiveProperties, boundProps, targetBoundDirectiveProps, targetBoundDirectivePropNames) { |
| if (directiveProperties) { |
| var boundPropsByName_1 = new Map(); |
| boundProps.forEach(function (boundProp) { |
| var prevValue = boundPropsByName_1.get(boundProp.name); |
| if (!prevValue || prevValue.isLiteral) { |
| // give [a]="b" a higher precedence than a="b" on the same element |
| boundPropsByName_1.set(boundProp.name, boundProp); |
| } |
| }); |
| Object.keys(directiveProperties).forEach(function (dirProp) { |
| var elProp = directiveProperties[dirProp]; |
| var boundProp = boundPropsByName_1.get(elProp); |
| // Bindings are optional, so this binding only needs to be set up if an expression is given. |
| if (boundProp) { |
| targetBoundDirectivePropNames.add(boundProp.name); |
| if (!isEmptyExpression(boundProp.expression)) { |
| targetBoundDirectiveProps.push(new BoundDirectivePropertyAst(dirProp, boundProp.name, boundProp.expression, boundProp.sourceSpan)); |
| } |
| } |
| }); |
| } |
| }; |
| TemplateParseVisitor.prototype._createElementPropertyAsts = function (elementName, props, boundDirectivePropNames) { |
| var _this = this; |
| var boundElementProps = []; |
| props.forEach(function (prop) { |
| if (!prop.isLiteral && !boundDirectivePropNames.has(prop.name)) { |
| var boundProp = _this._bindingParser.createBoundElementProperty(elementName, prop); |
| boundElementProps.push(BoundElementPropertyAst.fromBoundProperty(boundProp)); |
| } |
| }); |
| return this._checkPropertiesInSchema(elementName, boundElementProps); |
| }; |
| TemplateParseVisitor.prototype._findComponentDirectives = function (directives) { |
| return directives.filter(function (directive) { return directive.directive.isComponent; }); |
| }; |
| TemplateParseVisitor.prototype._findComponentDirectiveNames = function (directives) { |
| return this._findComponentDirectives(directives) |
| .map(function (directive) { return identifierName(directive.directive.type); }); |
| }; |
| TemplateParseVisitor.prototype._assertOnlyOneComponent = function (directives, sourceSpan) { |
| var componentTypeNames = this._findComponentDirectiveNames(directives); |
| if (componentTypeNames.length > 1) { |
| this._reportError("More than one component matched on this element.\n" + |
| "Make sure that only one component's selector can match a given element.\n" + |
| ("Conflicting components: " + componentTypeNames.join(',')), sourceSpan); |
| } |
| }; |
| /** |
| * Make sure that non-angular tags conform to the schemas. |
| * |
| * Note: An element is considered an angular tag when at least one directive selector matches the |
| * tag name. |
| * |
| * @param matchElement Whether any directive has matched on the tag name |
| * @param element the html element |
| */ |
| TemplateParseVisitor.prototype._assertElementExists = function (matchElement, element) { |
| var elName = element.name.replace(/^:xhtml:/, ''); |
| if (!matchElement && !this._schemaRegistry.hasElement(elName, this._schemas)) { |
| var errorMsg = "'" + elName + "' is not a known element:\n"; |
| errorMsg += |
| "1. If '" + elName + "' is an Angular component, then verify that it is part of this module.\n"; |
| if (elName.indexOf('-') > -1) { |
| errorMsg += |
| "2. If '" + elName + "' is a Web Component then add 'CUSTOM_ELEMENTS_SCHEMA' to the '@NgModule.schemas' of this component to suppress this message."; |
| } |
| else { |
| errorMsg += |
| "2. To allow any element add 'NO_ERRORS_SCHEMA' to the '@NgModule.schemas' of this component."; |
| } |
| this._reportError(errorMsg, element.sourceSpan); |
| } |
| }; |
| TemplateParseVisitor.prototype._assertNoComponentsNorElementBindingsOnTemplate = function (directives, elementProps, sourceSpan) { |
| var _this = this; |
| var componentTypeNames = this._findComponentDirectiveNames(directives); |
| if (componentTypeNames.length > 0) { |
| this._reportError("Components on an embedded template: " + componentTypeNames.join(','), sourceSpan); |
| } |
| elementProps.forEach(function (prop) { |
| _this._reportError("Property binding " + prop.name + " not used by any directive on an embedded template. Make sure that the property name is spelled correctly and all directives are listed in the \"@NgModule.declarations\".", sourceSpan); |
| }); |
| }; |
| TemplateParseVisitor.prototype._assertAllEventsPublishedByDirectives = function (directives, events) { |
| var _this = this; |
| var allDirectiveEvents = new Set(); |
| directives.forEach(function (directive) { |
| Object.keys(directive.directive.outputs).forEach(function (k) { |
| var eventName = directive.directive.outputs[k]; |
| allDirectiveEvents.add(eventName); |
| }); |
| }); |
| events.forEach(function (event) { |
| if (event.target != null || !allDirectiveEvents.has(event.name)) { |
| _this._reportError("Event binding " + event.fullName + " not emitted by any directive on an embedded template. Make sure that the event name is spelled correctly and all directives are listed in the \"@NgModule.declarations\".", event.sourceSpan); |
| } |
| }); |
| }; |
| TemplateParseVisitor.prototype._checkPropertiesInSchema = function (elementName, boundProps) { |
| var _this = this; |
| // Note: We can't filter out empty expressions before this method, |
| // as we still want to validate them! |
| return boundProps.filter(function (boundProp) { |
| if (boundProp.type === 0 /* Property */ && |
| !_this._schemaRegistry.hasProperty(elementName, boundProp.name, _this._schemas)) { |
| var errorMsg = "Can't bind to '" + boundProp.name + "' since it isn't a known property of '" + elementName + "'."; |
| if (elementName.startsWith('ng-')) { |
| errorMsg += |
| "\n1. If '" + boundProp.name + "' is an Angular directive, then add 'CommonModule' to the '@NgModule.imports' of this component." + |
| "\n2. To allow any property add 'NO_ERRORS_SCHEMA' to the '@NgModule.schemas' of this component."; |
| } |
| else if (elementName.indexOf('-') > -1) { |
| errorMsg += |
| "\n1. If '" + elementName + "' is an Angular component and it has '" + boundProp.name + "' input, then verify that it is part of this module." + |
| ("\n2. If '" + elementName + "' is a Web Component then add 'CUSTOM_ELEMENTS_SCHEMA' to the '@NgModule.schemas' of this component to suppress this message.") + |
| "\n3. To allow any property add 'NO_ERRORS_SCHEMA' to the '@NgModule.schemas' of this component."; |
| } |
| _this._reportError(errorMsg, boundProp.sourceSpan); |
| } |
| return !isEmptyExpression(boundProp.value); |
| }); |
| }; |
| TemplateParseVisitor.prototype._reportError = function (message, sourceSpan, level) { |
| if (level === void 0) { level = exports.ParseErrorLevel.ERROR; } |
| this._targetErrors.push(new ParseError(sourceSpan, message, level)); |
| }; |
| return TemplateParseVisitor; |
| }()); |
| var NonBindableVisitor = /** @class */ (function () { |
| function NonBindableVisitor() { |
| } |
| NonBindableVisitor.prototype.visitElement = function (ast, parent) { |
| var preparsedElement = preparseElement(ast); |
| if (preparsedElement.type === PreparsedElementType.SCRIPT || |
| preparsedElement.type === PreparsedElementType.STYLE || |
| preparsedElement.type === PreparsedElementType.STYLESHEET) { |
| // Skipping <script> for security reasons |
| // Skipping <style> and stylesheets as we already processed them |
| // in the StyleCompiler |
| return null; |
| } |
| var attrNameAndValues = ast.attrs.map(function (attr) { return [attr.name, attr.value]; }); |
| var selector = createElementCssSelector(ast.name, attrNameAndValues); |
| var ngContentIndex = parent.findNgContentIndex(selector); |
| var children = visitAll$1(this, ast.children, EMPTY_ELEMENT_CONTEXT); |
| return new ElementAst(ast.name, visitAll$1(this, ast.attrs), [], [], [], [], [], false, [], children, ngContentIndex, ast.sourceSpan, ast.endSourceSpan); |
| }; |
| NonBindableVisitor.prototype.visitComment = function (comment, context) { return null; }; |
| NonBindableVisitor.prototype.visitAttribute = function (attribute, context) { |
| return new AttrAst(attribute.name, attribute.value, attribute.sourceSpan); |
| }; |
| NonBindableVisitor.prototype.visitText = function (text, parent) { |
| var ngContentIndex = parent.findNgContentIndex(TEXT_CSS_SELECTOR()); |
| return new TextAst(text.value, ngContentIndex, text.sourceSpan); |
| }; |
| NonBindableVisitor.prototype.visitExpansion = function (expansion, context) { return expansion; }; |
| NonBindableVisitor.prototype.visitExpansionCase = function (expansionCase, context) { return expansionCase; }; |
| return NonBindableVisitor; |
| }()); |
| /** |
| * A reference to an element or directive in a template. E.g., the reference in this template: |
| * |
| * <div #myMenu="coolMenu"> |
| * |
| * would be {name: 'myMenu', value: 'coolMenu', sourceSpan: ...} |
| */ |
| var ElementOrDirectiveRef = /** @class */ (function () { |
| function ElementOrDirectiveRef(name, value, sourceSpan) { |
| this.name = name; |
| this.value = value; |
| this.sourceSpan = sourceSpan; |
| } |
| /** Gets whether this is a reference to the given directive. */ |
| ElementOrDirectiveRef.prototype.isReferenceToDirective = function (directive) { |
| return splitExportAs(directive.exportAs).indexOf(this.value) !== -1; |
| }; |
| return ElementOrDirectiveRef; |
| }()); |
| /** Splits a raw, potentially comma-delimited `exportAs` value into an array of names. */ |
| function splitExportAs(exportAs) { |
| return exportAs ? exportAs.split(',').map(function (e) { return e.trim(); }) : []; |
| } |
| function splitClasses(classAttrValue) { |
| return classAttrValue.trim().split(/\s+/g); |
| } |
| var ElementContext = /** @class */ (function () { |
| function ElementContext(isTemplateElement, _ngContentIndexMatcher, _wildcardNgContentIndex, providerContext) { |
| this.isTemplateElement = isTemplateElement; |
| this._ngContentIndexMatcher = _ngContentIndexMatcher; |
| this._wildcardNgContentIndex = _wildcardNgContentIndex; |
| this.providerContext = providerContext; |
| } |
| ElementContext.create = function (isTemplateElement, directives, providerContext) { |
| var matcher = new SelectorMatcher(); |
| var wildcardNgContentIndex = null; |
| var component = directives.find(function (directive) { return directive.directive.isComponent; }); |
| if (component) { |
| var ngContentSelectors = component.directive.template.ngContentSelectors; |
| for (var i = 0; i < ngContentSelectors.length; i++) { |
| var selector = ngContentSelectors[i]; |
| if (selector === '*') { |
| wildcardNgContentIndex = i; |
| } |
| else { |
| matcher.addSelectables(CssSelector.parse(ngContentSelectors[i]), i); |
| } |
| } |
| } |
| return new ElementContext(isTemplateElement, matcher, wildcardNgContentIndex, providerContext); |
| }; |
| ElementContext.prototype.findNgContentIndex = function (selector) { |
| var ngContentIndices = []; |
| this._ngContentIndexMatcher.match(selector, function (selector, ngContentIndex) { ngContentIndices.push(ngContentIndex); }); |
| ngContentIndices.sort(); |
| if (this._wildcardNgContentIndex != null) { |
| ngContentIndices.push(this._wildcardNgContentIndex); |
| } |
| return ngContentIndices.length > 0 ? ngContentIndices[0] : null; |
| }; |
| return ElementContext; |
| }()); |
| function createElementCssSelector(elementName, attributes) { |
| var cssSelector = new CssSelector(); |
| var elNameNoNs = splitNsName(elementName)[1]; |
| cssSelector.setElement(elNameNoNs); |
| for (var i = 0; i < attributes.length; i++) { |
| var attrName = attributes[i][0]; |
| var attrNameNoNs = splitNsName(attrName)[1]; |
| var attrValue = attributes[i][1]; |
| cssSelector.addAttribute(attrNameNoNs, attrValue); |
| if (attrName.toLowerCase() == CLASS_ATTR) { |
| var classes = splitClasses(attrValue); |
| classes.forEach(function (className) { return cssSelector.addClassName(className); }); |
| } |
| } |
| return cssSelector; |
| } |
| var EMPTY_ELEMENT_CONTEXT = new ElementContext(true, new SelectorMatcher(), null, null); |
| var NON_BINDABLE_VISITOR = new NonBindableVisitor(); |
| function _isEmptyTextNode(node) { |
| return node instanceof Text$3 && node.value.trim().length == 0; |
| } |
| function removeSummaryDuplicates(items) { |
| var map = new Map(); |
| items.forEach(function (item) { |
| if (!map.get(item.type.reference)) { |
| map.set(item.type.reference, item); |
| } |
| }); |
| return Array.from(map.values()); |
| } |
| function isEmptyExpression(ast) { |
| if (ast instanceof ASTWithSource) { |
| ast = ast.ast; |
| } |
| return ast instanceof EmptyExpr; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * Parses string representation of a style and converts it into object literal. |
| * |
| * @param value string representation of style as used in the `style` attribute in HTML. |
| * Example: `color: red; height: auto`. |
| * @returns An array of style property name and value pairs, e.g. `['color', 'red', 'height', |
| * 'auto']` |
| */ |
| function parse(value) { |
| // we use a string array here instead of a string map |
| // because a string-map is not guaranteed to retain the |
| // order of the entries whereas a string array can be |
| // construted in a [key, value, key, value] format. |
| var styles = []; |
| var i = 0; |
| var parenDepth = 0; |
| var quote = 0 /* QuoteNone */; |
| var valueStart = 0; |
| var propStart = 0; |
| var currentProp = null; |
| var valueHasQuotes = false; |
| while (i < value.length) { |
| var token = value.charCodeAt(i++); |
| switch (token) { |
| case 40 /* OpenParen */: |
| parenDepth++; |
| break; |
| case 41 /* CloseParen */: |
| parenDepth--; |
| break; |
| case 39 /* QuoteSingle */: |
| // valueStart needs to be there since prop values don't |
| // have quotes in CSS |
| valueHasQuotes = valueHasQuotes || valueStart > 0; |
| if (quote === 0 /* QuoteNone */) { |
| quote = 39 /* QuoteSingle */; |
| } |
| else if (quote === 39 /* QuoteSingle */ && value.charCodeAt(i - 1) !== 92 /* BackSlash */) { |
| quote = 0 /* QuoteNone */; |
| } |
| break; |
| case 34 /* QuoteDouble */: |
| // same logic as above |
| valueHasQuotes = valueHasQuotes || valueStart > 0; |
| if (quote === 0 /* QuoteNone */) { |
| quote = 34 /* QuoteDouble */; |
| } |
| else if (quote === 34 /* QuoteDouble */ && value.charCodeAt(i - 1) !== 92 /* BackSlash */) { |
| quote = 0 /* QuoteNone */; |
| } |
| break; |
| case 58 /* Colon */: |
| if (!currentProp && parenDepth === 0 && quote === 0 /* QuoteNone */) { |
| currentProp = hyphenate(value.substring(propStart, i - 1).trim()); |
| valueStart = i; |
| } |
| break; |
| case 59 /* Semicolon */: |
| if (currentProp && valueStart > 0 && parenDepth === 0 && quote === 0 /* QuoteNone */) { |
| var styleVal = value.substring(valueStart, i - 1).trim(); |
| styles.push(currentProp, valueHasQuotes ? stripUnnecessaryQuotes(styleVal) : styleVal); |
| propStart = i; |
| valueStart = 0; |
| currentProp = null; |
| valueHasQuotes = false; |
| } |
| break; |
| } |
| } |
| if (currentProp && valueStart) { |
| var styleVal = value.substr(valueStart).trim(); |
| styles.push(currentProp, valueHasQuotes ? stripUnnecessaryQuotes(styleVal) : styleVal); |
| } |
| return styles; |
| } |
| function stripUnnecessaryQuotes(value) { |
| var qS = value.charCodeAt(0); |
| var qE = value.charCodeAt(value.length - 1); |
| if (qS == qE && (qS == 39 /* QuoteSingle */ || qS == 34 /* QuoteDouble */)) { |
| var tempValue = value.substring(1, value.length - 1); |
| // special case to avoid using a multi-quoted string that was just chomped |
| // (e.g. `font-family: "Verdana", "sans-serif"`) |
| if (tempValue.indexOf('\'') == -1 && tempValue.indexOf('"') == -1) { |
| value = tempValue; |
| } |
| } |
| return value; |
| } |
| function hyphenate(value) { |
| return value.replace(/[a-z][A-Z]/g, function (v) { |
| return v.charAt(0) + '-' + v.charAt(1); |
| }).toLowerCase(); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var _stylingMode = 0; |
| function compilerIsNewStylingInUse() { |
| return _stylingMode > 0 /* UseOld */; |
| } |
| |
| var IMPORTANT_FLAG = '!important'; |
| /** |
| * Produces creation/update instructions for all styling bindings (class and style) |
| * |
| * It also produces the creation instruction to register all initial styling values |
| * (which are all the static class="..." and style="..." attribute values that exist |
| * on an element within a template). |
| * |
| * The builder class below handles producing instructions for the following cases: |
| * |
| * - Static style/class attributes (style="..." and class="...") |
| * - Dynamic style/class map bindings ([style]="map" and [class]="map|string") |
| * - Dynamic style/class property bindings ([style.prop]="exp" and [class.name]="exp") |
| * |
| * Due to the complex relationship of all of these cases, the instructions generated |
| * for these attributes/properties/bindings must be done so in the correct order. The |
| * order which these must be generated is as follows: |
| * |
| * if (createMode) { |
| * styling(...) |
| * } |
| * if (updateMode) { |
| * styleMap(...) |
| * classMap(...) |
| * styleProp(...) |
| * classProp(...) |
| * stylingApp(...) |
| * } |
| * |
| * The creation/update methods within the builder class produce these instructions. |
| */ |
| var StylingBuilder = /** @class */ (function () { |
| function StylingBuilder(_elementIndexExpr, _directiveExpr) { |
| this._elementIndexExpr = _elementIndexExpr; |
| this._directiveExpr = _directiveExpr; |
| /** Whether or not there are any static styling values present */ |
| this._hasInitialValues = false; |
| /** |
| * Whether or not there are any styling bindings present |
| * (i.e. `[style]`, `[class]`, `[style.prop]` or `[class.name]`) |
| */ |
| this.hasBindings = false; |
| /** the input for [class] (if it exists) */ |
| this._classMapInput = null; |
| /** the input for [style] (if it exists) */ |
| this._styleMapInput = null; |
| /** an array of each [style.prop] input */ |
| this._singleStyleInputs = null; |
| /** an array of each [class.name] input */ |
| this._singleClassInputs = null; |
| this._lastStylingInput = null; |
| this._firstStylingInput = null; |
| // maps are used instead of hash maps because a Map will |
| // retain the ordering of the keys |
| /** |
| * Represents the location of each style binding in the template |
| * (e.g. `<div [style.width]="w" [style.height]="h">` implies |
| * that `width=0` and `height=1`) |
| */ |
| this._stylesIndex = new Map(); |
| /** |
| * Represents the location of each class binding in the template |
| * (e.g. `<div [class.big]="b" [class.hidden]="h">` implies |
| * that `big=0` and `hidden=1`) |
| */ |
| this._classesIndex = new Map(); |
| this._initialStyleValues = []; |
| this._initialClassValues = []; |
| // certain style properties ALWAYS need sanitization |
| // this is checked each time new styles are encountered |
| this._useDefaultSanitizer = false; |
| } |
| /** |
| * Registers a given input to the styling builder to be later used when producing AOT code. |
| * |
| * The code below will only accept the input if it is somehow tied to styling (whether it be |
| * style/class bindings or static style/class attributes). |
| */ |
| StylingBuilder.prototype.registerBoundInput = function (input) { |
| // [attr.style] or [attr.class] are skipped in the code below, |
| // they should not be treated as styling-based bindings since |
| // they are intended to be written directly to the attr and |
| // will therefore skip all style/class resolution that is present |
| // with style="", [style]="" and [style.prop]="", class="", |
| // [class.prop]="". [class]="" assignments |
| var binding = null; |
| var name = input.name; |
| switch (input.type) { |
| case 0 /* Property */: |
| binding = this.registerInputBasedOnName(name, input.value, input.sourceSpan); |
| break; |
| case 3 /* Style */: |
| binding = this.registerStyleInput(name, false, input.value, input.sourceSpan, input.unit); |
| break; |
| case 2 /* Class */: |
| binding = this.registerClassInput(name, false, input.value, input.sourceSpan); |
| break; |
| } |
| return binding ? true : false; |
| }; |
| StylingBuilder.prototype.registerInputBasedOnName = function (name, expression, sourceSpan) { |
| var binding = null; |
| var nameToMatch = name.substring(0, 5); // class | style |
| var isStyle = nameToMatch === 'style'; |
| var isClass = isStyle ? false : (nameToMatch === 'class'); |
| if (isStyle || isClass) { |
| var isMapBased = name.charAt(5) !== '.'; // style.prop or class.prop makes this a no |
| var property = name.substr(isMapBased ? 5 : 6); // the dot explains why there's a +1 |
| if (isStyle) { |
| binding = this.registerStyleInput(property, isMapBased, expression, sourceSpan); |
| } |
| else { |
| binding = this.registerClassInput(property, isMapBased, expression, sourceSpan); |
| } |
| } |
| return binding; |
| }; |
| StylingBuilder.prototype.registerStyleInput = function (name, isMapBased, value, sourceSpan, unit) { |
| if (isEmptyExpression(value)) { |
| return null; |
| } |
| var _a = parseProperty(name), property = _a.property, hasOverrideFlag = _a.hasOverrideFlag, bindingUnit = _a.unit; |
| var entry = { |
| name: property, |
| unit: unit || bindingUnit, value: value, sourceSpan: sourceSpan, hasOverrideFlag: hasOverrideFlag |
| }; |
| if (isMapBased) { |
| this._useDefaultSanitizer = true; |
| this._styleMapInput = entry; |
| } |
| else { |
| (this._singleStyleInputs = this._singleStyleInputs || []).push(entry); |
| this._useDefaultSanitizer = this._useDefaultSanitizer || isStyleSanitizable(name); |
| registerIntoMap(this._stylesIndex, property); |
| } |
| this._lastStylingInput = entry; |
| this._firstStylingInput = this._firstStylingInput || entry; |
| this.hasBindings = true; |
| return entry; |
| }; |
| StylingBuilder.prototype.registerClassInput = function (name, isMapBased, value, sourceSpan) { |
| if (isEmptyExpression(value)) { |
| return null; |
| } |
| var _a = parseProperty(name), property = _a.property, hasOverrideFlag = _a.hasOverrideFlag; |
| var entry = { name: property, value: value, sourceSpan: sourceSpan, hasOverrideFlag: hasOverrideFlag, unit: null }; |
| if (isMapBased) { |
| this._classMapInput = entry; |
| } |
| else { |
| (this._singleClassInputs = this._singleClassInputs || []).push(entry); |
| registerIntoMap(this._classesIndex, property); |
| } |
| this._lastStylingInput = entry; |
| this._firstStylingInput = this._firstStylingInput || entry; |
| this.hasBindings = true; |
| return entry; |
| }; |
| /** |
| * Registers the element's static style string value to the builder. |
| * |
| * @param value the style string (e.g. `width:100px; height:200px;`) |
| */ |
| StylingBuilder.prototype.registerStyleAttr = function (value) { |
| this._initialStyleValues = parse(value); |
| this._hasInitialValues = true; |
| }; |
| /** |
| * Registers the element's static class string value to the builder. |
| * |
| * @param value the className string (e.g. `disabled gold zoom`) |
| */ |
| StylingBuilder.prototype.registerClassAttr = function (value) { |
| this._initialClassValues = value.trim().split(/\s+/g); |
| this._hasInitialValues = true; |
| }; |
| /** |
| * Appends all styling-related expressions to the provided attrs array. |
| * |
| * @param attrs an existing array where each of the styling expressions |
| * will be inserted into. |
| */ |
| StylingBuilder.prototype.populateInitialStylingAttrs = function (attrs) { |
| // [CLASS_MARKER, 'foo', 'bar', 'baz' ...] |
| if (this._initialClassValues.length) { |
| attrs.push(literal(1 /* Classes */)); |
| for (var i = 0; i < this._initialClassValues.length; i++) { |
| attrs.push(literal(this._initialClassValues[i])); |
| } |
| } |
| // [STYLE_MARKER, 'width', '200px', 'height', '100px', ...] |
| if (this._initialStyleValues.length) { |
| attrs.push(literal(2 /* Styles */)); |
| for (var i = 0; i < this._initialStyleValues.length; i += 2) { |
| attrs.push(literal(this._initialStyleValues[i]), literal(this._initialStyleValues[i + 1])); |
| } |
| } |
| }; |
| /** |
| * Builds an instruction with all the expressions and parameters for `elementHostAttrs`. |
| * |
| * The instruction generation code below is used for producing the AOT statement code which is |
| * responsible for registering initial styles (within a directive hostBindings' creation block), |
| * as well as any of the provided attribute values, to the directive host element. |
| */ |
| StylingBuilder.prototype.buildHostAttrsInstruction = function (sourceSpan, attrs, constantPool) { |
| var _this = this; |
| if (this._directiveExpr && (attrs.length || this._hasInitialValues)) { |
| return { |
| sourceSpan: sourceSpan, |
| reference: Identifiers$1.elementHostAttrs, |
| allocateBindingSlots: 0, |
| buildParams: function () { |
| // params => elementHostAttrs(attrs) |
| _this.populateInitialStylingAttrs(attrs); |
| var attrArray = !attrs.some(function (attr) { return attr instanceof WrappedNodeExpr; }) ? |
| getConstantLiteralFromArray(constantPool, attrs) : |
| literalArr(attrs); |
| return [attrArray]; |
| } |
| }; |
| } |
| return null; |
| }; |
| /** |
| * Builds an instruction with all the expressions and parameters for `styling`. |
| * |
| * The instruction generation code below is used for producing the AOT statement code which is |
| * responsible for registering style/class bindings to an element. |
| */ |
| StylingBuilder.prototype.buildStylingInstruction = function (sourceSpan, constantPool) { |
| var _this = this; |
| if (this.hasBindings) { |
| return { |
| sourceSpan: sourceSpan, |
| allocateBindingSlots: 0, |
| reference: Identifiers$1.styling, |
| buildParams: function () { |
| // a string array of every style-based binding |
| var styleBindingProps = _this._singleStyleInputs ? _this._singleStyleInputs.map(function (i) { return literal(i.name); }) : []; |
| // a string array of every class-based binding |
| var classBindingNames = _this._singleClassInputs ? _this._singleClassInputs.map(function (i) { return literal(i.name); }) : []; |
| // to salvage space in the AOT generated code, there is no point in passing |
| // in `null` into a param if any follow-up params are not used. Therefore, |
| // only when a trailing param is used then it will be filled with nulls in between |
| // (otherwise a shorter amount of params will be filled). The code below helps |
| // determine how many params are required in the expression code. |
| // |
| // min params => styling() |
| // max params => styling(classBindings, styleBindings, sanitizer) |
| // |
| var params = []; |
| var expectedNumberOfArgs = 0; |
| if (_this._useDefaultSanitizer) { |
| expectedNumberOfArgs = 3; |
| } |
| else if (styleBindingProps.length) { |
| expectedNumberOfArgs = 2; |
| } |
| else if (classBindingNames.length) { |
| expectedNumberOfArgs = 1; |
| } |
| addParam(params, classBindingNames.length > 0, getConstantLiteralFromArray(constantPool, classBindingNames), 1, expectedNumberOfArgs); |
| addParam(params, styleBindingProps.length > 0, getConstantLiteralFromArray(constantPool, styleBindingProps), 2, expectedNumberOfArgs); |
| addParam(params, _this._useDefaultSanitizer, importExpr(Identifiers$1.defaultStyleSanitizer), 3, expectedNumberOfArgs); |
| return params; |
| } |
| }; |
| } |
| return null; |
| }; |
| /** |
| * Builds an instruction with all the expressions and parameters for `classMap`. |
| * |
| * The instruction data will contain all expressions for `classMap` to function |
| * which includes the `[class]` expression params. |
| */ |
| StylingBuilder.prototype.buildClassMapInstruction = function (valueConverter) { |
| if (this._classMapInput) { |
| return this._buildMapBasedInstruction(valueConverter, true, this._classMapInput); |
| } |
| return null; |
| }; |
| /** |
| * Builds an instruction with all the expressions and parameters for `styleMap`. |
| * |
| * The instruction data will contain all expressions for `styleMap` to function |
| * which includes the `[style]` expression params. |
| */ |
| StylingBuilder.prototype.buildStyleMapInstruction = function (valueConverter) { |
| if (this._styleMapInput) { |
| return this._buildMapBasedInstruction(valueConverter, false, this._styleMapInput); |
| } |
| return null; |
| }; |
| StylingBuilder.prototype._buildMapBasedInstruction = function (valueConverter, isClassBased, stylingInput) { |
| var totalBindingSlotsRequired = 0; |
| if (compilerIsNewStylingInUse()) { |
| // the old implementation does not reserve slot values for |
| // binding entries. The new one does. |
| totalBindingSlotsRequired++; |
| } |
| // these values must be outside of the update block so that they can |
| // be evaluated (the AST visit call) during creation time so that any |
| // pipes can be picked up in time before the template is built |
| var mapValue = stylingInput.value.visit(valueConverter); |
| if (mapValue instanceof Interpolation) { |
| totalBindingSlotsRequired += mapValue.expressions.length; |
| } |
| var reference = isClassBased ? Identifiers$1.classMap : Identifiers$1.styleMap; |
| return { |
| sourceSpan: stylingInput.sourceSpan, |
| reference: reference, |
| allocateBindingSlots: totalBindingSlotsRequired, |
| buildParams: function (convertFn) { return [convertFn(mapValue)]; } |
| }; |
| }; |
| StylingBuilder.prototype._buildSingleInputs = function (reference, inputs, mapIndex, allowUnits, valueConverter) { |
| var totalBindingSlotsRequired = 0; |
| return inputs.map(function (input) { |
| var bindingIndex = mapIndex.get(input.name); |
| var value = input.value.visit(valueConverter); |
| totalBindingSlotsRequired += (value instanceof Interpolation) ? value.expressions.length : 0; |
| if (compilerIsNewStylingInUse()) { |
| // the old implementation does not reserve slot values for |
| // binding entries. The new one does. |
| totalBindingSlotsRequired++; |
| } |
| return { |
| sourceSpan: input.sourceSpan, |
| allocateBindingSlots: totalBindingSlotsRequired, reference: reference, |
| buildParams: function (convertFn) { |
| // min params => stylingProp(elmIndex, bindingIndex, value) |
| // max params => stylingProp(elmIndex, bindingIndex, value, overrideFlag) |
| var params = []; |
| params.push(literal(bindingIndex)); |
| params.push(convertFn(value)); |
| if (allowUnits) { |
| if (input.unit) { |
| params.push(literal(input.unit)); |
| } |
| else if (input.hasOverrideFlag) { |
| params.push(NULL_EXPR); |
| } |
| } |
| if (input.hasOverrideFlag) { |
| params.push(literal(true)); |
| } |
| return params; |
| } |
| }; |
| }); |
| }; |
| StylingBuilder.prototype._buildClassInputs = function (valueConverter) { |
| if (this._singleClassInputs) { |
| return this._buildSingleInputs(Identifiers$1.classProp, this._singleClassInputs, this._classesIndex, false, valueConverter); |
| } |
| return []; |
| }; |
| StylingBuilder.prototype._buildStyleInputs = function (valueConverter) { |
| if (this._singleStyleInputs) { |
| return this._buildSingleInputs(Identifiers$1.styleProp, this._singleStyleInputs, this._stylesIndex, true, valueConverter); |
| } |
| return []; |
| }; |
| StylingBuilder.prototype._buildApplyFn = function () { |
| return { |
| sourceSpan: this._lastStylingInput ? this._lastStylingInput.sourceSpan : null, |
| reference: Identifiers$1.stylingApply, |
| allocateBindingSlots: 0, |
| buildParams: function () { return []; } |
| }; |
| }; |
| StylingBuilder.prototype._buildSanitizerFn = function () { |
| return { |
| sourceSpan: this._firstStylingInput ? this._firstStylingInput.sourceSpan : null, |
| reference: Identifiers$1.styleSanitizer, |
| allocateBindingSlots: 0, |
| buildParams: function () { return [importExpr(Identifiers$1.defaultStyleSanitizer)]; } |
| }; |
| }; |
| /** |
| * Constructs all instructions which contain the expressions that will be placed |
| * into the update block of a template function or a directive hostBindings function. |
| */ |
| StylingBuilder.prototype.buildUpdateLevelInstructions = function (valueConverter) { |
| var instructions = []; |
| if (this.hasBindings) { |
| if (compilerIsNewStylingInUse() && this._useDefaultSanitizer) { |
| instructions.push(this._buildSanitizerFn()); |
| } |
| var styleMapInstruction = this.buildStyleMapInstruction(valueConverter); |
| if (styleMapInstruction) { |
| instructions.push(styleMapInstruction); |
| } |
| var classMapInstruction = this.buildClassMapInstruction(valueConverter); |
| if (classMapInstruction) { |
| instructions.push(classMapInstruction); |
| } |
| instructions.push.apply(instructions, __spread(this._buildStyleInputs(valueConverter))); |
| instructions.push.apply(instructions, __spread(this._buildClassInputs(valueConverter))); |
| instructions.push(this._buildApplyFn()); |
| } |
| return instructions; |
| }; |
| return StylingBuilder; |
| }()); |
| function registerIntoMap(map, key) { |
| if (!map.has(key)) { |
| map.set(key, map.size); |
| } |
| } |
| function isStyleSanitizable(prop) { |
| // Note that browsers support both the dash case and |
| // camel case property names when setting through JS. |
| return prop === 'background-image' || prop === 'backgroundImage' || prop === 'background' || |
| prop === 'border-image' || prop === 'borderImage' || prop === 'filter' || |
| prop === 'list-style' || prop === 'listStyle' || prop === 'list-style-image' || |
| prop === 'listStyleImage' || prop === 'clip-path' || prop === 'clipPath'; |
| } |
| /** |
| * Simple helper function to either provide the constant literal that will house the value |
| * here or a null value if the provided values are empty. |
| */ |
| function getConstantLiteralFromArray(constantPool, values) { |
| return values.length ? constantPool.getConstLiteral(literalArr(values), true) : NULL_EXPR; |
| } |
| /** |
| * Simple helper function that adds a parameter or does nothing at all depending on the provided |
| * predicate and totalExpectedArgs values |
| */ |
| function addParam(params, predicate, value, argNumber, totalExpectedArgs) { |
| if (predicate && value) { |
| params.push(value); |
| } |
| else if (argNumber < totalExpectedArgs) { |
| params.push(NULL_EXPR); |
| } |
| } |
| function parseProperty(name) { |
| var hasOverrideFlag = false; |
| var overrideIndex = name.indexOf(IMPORTANT_FLAG); |
| if (overrideIndex !== -1) { |
| name = overrideIndex > 0 ? name.substring(0, overrideIndex) : ''; |
| hasOverrideFlag = true; |
| } |
| var unit = ''; |
| var property = name; |
| var unitIndex = name.lastIndexOf('.'); |
| if (unitIndex > 0) { |
| unit = name.substr(unitIndex + 1); |
| property = name.substring(0, unitIndex); |
| } |
| return { property: property, unit: unit, hasOverrideFlag: hasOverrideFlag }; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| (function (TokenType) { |
| TokenType[TokenType["Character"] = 0] = "Character"; |
| TokenType[TokenType["Identifier"] = 1] = "Identifier"; |
| TokenType[TokenType["Keyword"] = 2] = "Keyword"; |
| TokenType[TokenType["String"] = 3] = "String"; |
| TokenType[TokenType["Operator"] = 4] = "Operator"; |
| TokenType[TokenType["Number"] = 5] = "Number"; |
| TokenType[TokenType["Error"] = 6] = "Error"; |
| })(exports.TokenType || (exports.TokenType = {})); |
| var KEYWORDS = ['var', 'let', 'as', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this']; |
| var Lexer = /** @class */ (function () { |
| function Lexer() { |
| } |
| Lexer.prototype.tokenize = function (text) { |
| var scanner = new _Scanner(text); |
| var tokens = []; |
| var token = scanner.scanToken(); |
| while (token != null) { |
| tokens.push(token); |
| token = scanner.scanToken(); |
| } |
| return tokens; |
| }; |
| return Lexer; |
| }()); |
| var Token$1 = /** @class */ (function () { |
| function Token(index, type, numValue, strValue) { |
| this.index = index; |
| this.type = type; |
| this.numValue = numValue; |
| this.strValue = strValue; |
| } |
| Token.prototype.isCharacter = function (code) { |
| return this.type == exports.TokenType.Character && this.numValue == code; |
| }; |
| Token.prototype.isNumber = function () { return this.type == exports.TokenType.Number; }; |
| Token.prototype.isString = function () { return this.type == exports.TokenType.String; }; |
| Token.prototype.isOperator = function (operator) { |
| return this.type == exports.TokenType.Operator && this.strValue == operator; |
| }; |
| Token.prototype.isIdentifier = function () { return this.type == exports.TokenType.Identifier; }; |
| Token.prototype.isKeyword = function () { return this.type == exports.TokenType.Keyword; }; |
| Token.prototype.isKeywordLet = function () { return this.type == exports.TokenType.Keyword && this.strValue == 'let'; }; |
| Token.prototype.isKeywordAs = function () { return this.type == exports.TokenType.Keyword && this.strValue == 'as'; }; |
| Token.prototype.isKeywordNull = function () { return this.type == exports.TokenType.Keyword && this.strValue == 'null'; }; |
| Token.prototype.isKeywordUndefined = function () { |
| return this.type == exports.TokenType.Keyword && this.strValue == 'undefined'; |
| }; |
| Token.prototype.isKeywordTrue = function () { return this.type == exports.TokenType.Keyword && this.strValue == 'true'; }; |
| Token.prototype.isKeywordFalse = function () { return this.type == exports.TokenType.Keyword && this.strValue == 'false'; }; |
| Token.prototype.isKeywordThis = function () { return this.type == exports.TokenType.Keyword && this.strValue == 'this'; }; |
| Token.prototype.isError = function () { return this.type == exports.TokenType.Error; }; |
| Token.prototype.toNumber = function () { return this.type == exports.TokenType.Number ? this.numValue : -1; }; |
| Token.prototype.toString = function () { |
| switch (this.type) { |
| case exports.TokenType.Character: |
| case exports.TokenType.Identifier: |
| case exports.TokenType.Keyword: |
| case exports.TokenType.Operator: |
| case exports.TokenType.String: |
| case exports.TokenType.Error: |
| return this.strValue; |
| case exports.TokenType.Number: |
| return this.numValue.toString(); |
| default: |
| return null; |
| } |
| }; |
| return Token; |
| }()); |
| function newCharacterToken(index, code) { |
| return new Token$1(index, exports.TokenType.Character, code, String.fromCharCode(code)); |
| } |
| function newIdentifierToken(index, text) { |
| return new Token$1(index, exports.TokenType.Identifier, 0, text); |
| } |
| function newKeywordToken(index, text) { |
| return new Token$1(index, exports.TokenType.Keyword, 0, text); |
| } |
| function newOperatorToken(index, text) { |
| return new Token$1(index, exports.TokenType.Operator, 0, text); |
| } |
| function newStringToken(index, text) { |
| return new Token$1(index, exports.TokenType.String, 0, text); |
| } |
| function newNumberToken(index, n) { |
| return new Token$1(index, exports.TokenType.Number, n, ''); |
| } |
| function newErrorToken(index, message) { |
| return new Token$1(index, exports.TokenType.Error, 0, message); |
| } |
| var EOF = new Token$1(-1, exports.TokenType.Character, 0, ''); |
| var _Scanner = /** @class */ (function () { |
| function _Scanner(input) { |
| this.input = input; |
| this.peek = 0; |
| this.index = -1; |
| this.length = input.length; |
| this.advance(); |
| } |
| _Scanner.prototype.advance = function () { |
| this.peek = ++this.index >= this.length ? $EOF : this.input.charCodeAt(this.index); |
| }; |
| _Scanner.prototype.scanToken = function () { |
| var input = this.input, length = this.length; |
| var peek = this.peek, index = this.index; |
| // Skip whitespace. |
| while (peek <= $SPACE) { |
| if (++index >= length) { |
| peek = $EOF; |
| break; |
| } |
| else { |
| peek = input.charCodeAt(index); |
| } |
| } |
| this.peek = peek; |
| this.index = index; |
| if (index >= length) { |
| return null; |
| } |
| // Handle identifiers and numbers. |
| if (isIdentifierStart(peek)) |
| return this.scanIdentifier(); |
| if (isDigit(peek)) |
| return this.scanNumber(index); |
| var start = index; |
| switch (peek) { |
| case $PERIOD: |
| this.advance(); |
| return isDigit(this.peek) ? this.scanNumber(start) : |
| newCharacterToken(start, $PERIOD); |
| case $LPAREN: |
| case $RPAREN: |
| case $LBRACE: |
| case $RBRACE: |
| case $LBRACKET: |
| case $RBRACKET: |
| case $COMMA: |
| case $COLON: |
| case $SEMICOLON: |
| return this.scanCharacter(start, peek); |
| case $SQ: |
| case $DQ: |
| return this.scanString(); |
| case $HASH: |
| case $PLUS: |
| case $MINUS: |
| case $STAR: |
| case $SLASH: |
| case $PERCENT: |
| case $CARET: |
| return this.scanOperator(start, String.fromCharCode(peek)); |
| case $QUESTION: |
| return this.scanComplexOperator(start, '?', $PERIOD, '.'); |
| case $LT: |
| case $GT: |
| return this.scanComplexOperator(start, String.fromCharCode(peek), $EQ, '='); |
| case $BANG: |
| case $EQ: |
| return this.scanComplexOperator(start, String.fromCharCode(peek), $EQ, '=', $EQ, '='); |
| case $AMPERSAND: |
| return this.scanComplexOperator(start, '&', $AMPERSAND, '&'); |
| case $BAR: |
| return this.scanComplexOperator(start, '|', $BAR, '|'); |
| case $NBSP: |
| while (isWhitespace(this.peek)) |
| this.advance(); |
| return this.scanToken(); |
| } |
| this.advance(); |
| return this.error("Unexpected character [" + String.fromCharCode(peek) + "]", 0); |
| }; |
| _Scanner.prototype.scanCharacter = function (start, code) { |
| this.advance(); |
| return newCharacterToken(start, code); |
| }; |
| _Scanner.prototype.scanOperator = function (start, str) { |
| this.advance(); |
| return newOperatorToken(start, str); |
| }; |
| /** |
| * Tokenize a 2/3 char long operator |
| * |
| * @param start start index in the expression |
| * @param one first symbol (always part of the operator) |
| * @param twoCode code point for the second symbol |
| * @param two second symbol (part of the operator when the second code point matches) |
| * @param threeCode code point for the third symbol |
| * @param three third symbol (part of the operator when provided and matches source expression) |
| */ |
| _Scanner.prototype.scanComplexOperator = function (start, one, twoCode, two, threeCode, three) { |
| this.advance(); |
| var str = one; |
| if (this.peek == twoCode) { |
| this.advance(); |
| str += two; |
| } |
| if (threeCode != null && this.peek == threeCode) { |
| this.advance(); |
| str += three; |
| } |
| return newOperatorToken(start, str); |
| }; |
| _Scanner.prototype.scanIdentifier = function () { |
| var start = this.index; |
| this.advance(); |
| while (isIdentifierPart(this.peek)) |
| this.advance(); |
| var str = this.input.substring(start, this.index); |
| return KEYWORDS.indexOf(str) > -1 ? newKeywordToken(start, str) : |
| newIdentifierToken(start, str); |
| }; |
| _Scanner.prototype.scanNumber = function (start) { |
| var simple = (this.index === start); |
| this.advance(); // Skip initial digit. |
| while (true) { |
| if (isDigit(this.peek)) ; |
| else if (this.peek == $PERIOD) { |
| simple = false; |
| } |
| else if (isExponentStart(this.peek)) { |
| this.advance(); |
| if (isExponentSign(this.peek)) |
| this.advance(); |
| if (!isDigit(this.peek)) |
| return this.error('Invalid exponent', -1); |
| simple = false; |
| } |
| else { |
| break; |
| } |
| this.advance(); |
| } |
| var str = this.input.substring(start, this.index); |
| var value = simple ? parseIntAutoRadix(str) : parseFloat(str); |
| return newNumberToken(start, value); |
| }; |
| _Scanner.prototype.scanString = function () { |
| var start = this.index; |
| var quote = this.peek; |
| this.advance(); // Skip initial quote. |
| var buffer = ''; |
| var marker = this.index; |
| var input = this.input; |
| while (this.peek != quote) { |
| if (this.peek == $BACKSLASH) { |
| buffer += input.substring(marker, this.index); |
| this.advance(); |
| var unescapedCode = void 0; |
| // Workaround for TS2.1-introduced type strictness |
| this.peek = this.peek; |
| if (this.peek == $u) { |
| // 4 character hex code for unicode character. |
| var hex = input.substring(this.index + 1, this.index + 5); |
| if (/^[0-9a-f]+$/i.test(hex)) { |
| unescapedCode = parseInt(hex, 16); |
| } |
| else { |
| return this.error("Invalid unicode escape [\\u" + hex + "]", 0); |
| } |
| for (var i = 0; i < 5; i++) { |
| this.advance(); |
| } |
| } |
| else { |
| unescapedCode = unescape(this.peek); |
| this.advance(); |
| } |
| buffer += String.fromCharCode(unescapedCode); |
| marker = this.index; |
| } |
| else if (this.peek == $EOF) { |
| return this.error('Unterminated quote', 0); |
| } |
| else { |
| this.advance(); |
| } |
| } |
| var last = input.substring(marker, this.index); |
| this.advance(); // Skip terminating quote. |
| return newStringToken(start, buffer + last); |
| }; |
| _Scanner.prototype.error = function (message, offset) { |
| var position = this.index + offset; |
| return newErrorToken(position, "Lexer Error: " + message + " at column " + position + " in expression [" + this.input + "]"); |
| }; |
| return _Scanner; |
| }()); |
| function isIdentifierStart(code) { |
| return ($a <= code && code <= $z) || ($A <= code && code <= $Z) || |
| (code == $_) || (code == $$); |
| } |
| function isIdentifier(input) { |
| if (input.length == 0) |
| return false; |
| var scanner = new _Scanner(input); |
| if (!isIdentifierStart(scanner.peek)) |
| return false; |
| scanner.advance(); |
| while (scanner.peek !== $EOF) { |
| if (!isIdentifierPart(scanner.peek)) |
| return false; |
| scanner.advance(); |
| } |
| return true; |
| } |
| function isIdentifierPart(code) { |
| return isAsciiLetter(code) || isDigit(code) || (code == $_) || |
| (code == $$); |
| } |
| function isExponentStart(code) { |
| return code == $e || code == $E; |
| } |
| function isExponentSign(code) { |
| return code == $MINUS || code == $PLUS; |
| } |
| function isQuote(code) { |
| return code === $SQ || code === $DQ || code === $BT; |
| } |
| function unescape(code) { |
| switch (code) { |
| case $n: |
| return $LF; |
| case $f: |
| return $FF; |
| case $r: |
| return $CR; |
| case $t: |
| return $TAB; |
| case $v: |
| return $VTAB; |
| default: |
| return code; |
| } |
| } |
| function parseIntAutoRadix(text) { |
| var result = parseInt(text); |
| if (isNaN(result)) { |
| throw new Error('Invalid integer literal when parsing ' + text); |
| } |
| return result; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var SplitInterpolation = /** @class */ (function () { |
| function SplitInterpolation(strings, expressions, offsets) { |
| this.strings = strings; |
| this.expressions = expressions; |
| this.offsets = offsets; |
| } |
| return SplitInterpolation; |
| }()); |
| var TemplateBindingParseResult = /** @class */ (function () { |
| function TemplateBindingParseResult(templateBindings, warnings, errors) { |
| this.templateBindings = templateBindings; |
| this.warnings = warnings; |
| this.errors = errors; |
| } |
| return TemplateBindingParseResult; |
| }()); |
| function _createInterpolateRegExp(config) { |
| var pattern = escapeRegExp(config.start) + '([\\s\\S]*?)' + escapeRegExp(config.end); |
| return new RegExp(pattern, 'g'); |
| } |
| var Parser$1 = /** @class */ (function () { |
| function Parser(_lexer) { |
| this._lexer = _lexer; |
| this.errors = []; |
| } |
| Parser.prototype.parseAction = function (input, location, interpolationConfig) { |
| if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; } |
| this._checkNoInterpolation(input, location, interpolationConfig); |
| var sourceToLex = this._stripComments(input); |
| var tokens = this._lexer.tokenize(this._stripComments(input)); |
| var ast = new _ParseAST(input, location, tokens, sourceToLex.length, true, this.errors, input.length - sourceToLex.length) |
| .parseChain(); |
| return new ASTWithSource(ast, input, location, this.errors); |
| }; |
| Parser.prototype.parseBinding = function (input, location, interpolationConfig) { |
| if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; } |
| var ast = this._parseBindingAst(input, location, interpolationConfig); |
| return new ASTWithSource(ast, input, location, this.errors); |
| }; |
| Parser.prototype.parseSimpleBinding = function (input, location, interpolationConfig) { |
| if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; } |
| var ast = this._parseBindingAst(input, location, interpolationConfig); |
| var errors = SimpleExpressionChecker.check(ast); |
| if (errors.length > 0) { |
| this._reportError("Host binding expression cannot contain " + errors.join(' '), input, location); |
| } |
| return new ASTWithSource(ast, input, location, this.errors); |
| }; |
| Parser.prototype._reportError = function (message, input, errLocation, ctxLocation) { |
| this.errors.push(new ParserError(message, input, errLocation, ctxLocation)); |
| }; |
| Parser.prototype._parseBindingAst = function (input, location, interpolationConfig) { |
| // Quotes expressions use 3rd-party expression language. We don't want to use |
| // our lexer or parser for that, so we check for that ahead of time. |
| var quote = this._parseQuote(input, location); |
| if (quote != null) { |
| return quote; |
| } |
| this._checkNoInterpolation(input, location, interpolationConfig); |
| var sourceToLex = this._stripComments(input); |
| var tokens = this._lexer.tokenize(sourceToLex); |
| return new _ParseAST(input, location, tokens, sourceToLex.length, false, this.errors, input.length - sourceToLex.length) |
| .parseChain(); |
| }; |
| Parser.prototype._parseQuote = function (input, location) { |
| if (input == null) |
| return null; |
| var prefixSeparatorIndex = input.indexOf(':'); |
| if (prefixSeparatorIndex == -1) |
| return null; |
| var prefix = input.substring(0, prefixSeparatorIndex).trim(); |
| if (!isIdentifier(prefix)) |
| return null; |
| var uninterpretedExpression = input.substring(prefixSeparatorIndex + 1); |
| return new Quote(new ParseSpan(0, input.length), prefix, uninterpretedExpression, location); |
| }; |
| Parser.prototype.parseTemplateBindings = function (tplKey, tplValue, location) { |
| var tokens = this._lexer.tokenize(tplValue); |
| return new _ParseAST(tplValue, location, tokens, tplValue.length, false, this.errors, 0) |
| .parseTemplateBindings(tplKey); |
| }; |
| Parser.prototype.parseInterpolation = function (input, location, interpolationConfig) { |
| if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; } |
| var split = this.splitInterpolation(input, location, interpolationConfig); |
| if (split == null) |
| return null; |
| var expressions = []; |
| for (var i = 0; i < split.expressions.length; ++i) { |
| var expressionText = split.expressions[i]; |
| var sourceToLex = this._stripComments(expressionText); |
| var tokens = this._lexer.tokenize(sourceToLex); |
| var ast = new _ParseAST(input, location, tokens, sourceToLex.length, false, this.errors, split.offsets[i] + (expressionText.length - sourceToLex.length)) |
| .parseChain(); |
| expressions.push(ast); |
| } |
| return new ASTWithSource(new Interpolation(new ParseSpan(0, input == null ? 0 : input.length), split.strings, expressions), input, location, this.errors); |
| }; |
| Parser.prototype.splitInterpolation = function (input, location, interpolationConfig) { |
| if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; } |
| var regexp = _createInterpolateRegExp(interpolationConfig); |
| var parts = input.split(regexp); |
| if (parts.length <= 1) { |
| return null; |
| } |
| var strings = []; |
| var expressions = []; |
| var offsets = []; |
| var offset = 0; |
| for (var i = 0; i < parts.length; i++) { |
| var part = parts[i]; |
| if (i % 2 === 0) { |
| // fixed string |
| strings.push(part); |
| offset += part.length; |
| } |
| else if (part.trim().length > 0) { |
| offset += interpolationConfig.start.length; |
| expressions.push(part); |
| offsets.push(offset); |
| offset += part.length + interpolationConfig.end.length; |
| } |
| else { |
| this._reportError('Blank expressions are not allowed in interpolated strings', input, "at column " + this._findInterpolationErrorColumn(parts, i, interpolationConfig) + " in", location); |
| expressions.push('$implict'); |
| offsets.push(offset); |
| } |
| } |
| return new SplitInterpolation(strings, expressions, offsets); |
| }; |
| Parser.prototype.wrapLiteralPrimitive = function (input, location) { |
| return new ASTWithSource(new LiteralPrimitive(new ParseSpan(0, input == null ? 0 : input.length), input), input, location, this.errors); |
| }; |
| Parser.prototype._stripComments = function (input) { |
| var i = this._commentStart(input); |
| return i != null ? input.substring(0, i).trim() : input; |
| }; |
| Parser.prototype._commentStart = function (input) { |
| var outerQuote = null; |
| for (var i = 0; i < input.length - 1; i++) { |
| var char = input.charCodeAt(i); |
| var nextChar = input.charCodeAt(i + 1); |
| if (char === $SLASH && nextChar == $SLASH && outerQuote == null) |
| return i; |
| if (outerQuote === char) { |
| outerQuote = null; |
| } |
| else if (outerQuote == null && isQuote(char)) { |
| outerQuote = char; |
| } |
| } |
| return null; |
| }; |
| Parser.prototype._checkNoInterpolation = function (input, location, interpolationConfig) { |
| var regexp = _createInterpolateRegExp(interpolationConfig); |
| var parts = input.split(regexp); |
| if (parts.length > 1) { |
| this._reportError("Got interpolation (" + interpolationConfig.start + interpolationConfig.end + ") where expression was expected", input, "at column " + this._findInterpolationErrorColumn(parts, 1, interpolationConfig) + " in", location); |
| } |
| }; |
| Parser.prototype._findInterpolationErrorColumn = function (parts, partInErrIdx, interpolationConfig) { |
| var errLocation = ''; |
| for (var j = 0; j < partInErrIdx; j++) { |
| errLocation += j % 2 === 0 ? |
| parts[j] : |
| "" + interpolationConfig.start + parts[j] + interpolationConfig.end; |
| } |
| return errLocation.length; |
| }; |
| return Parser; |
| }()); |
| var _ParseAST = /** @class */ (function () { |
| function _ParseAST(input, location, tokens, inputLength, parseAction, errors, offset) { |
| this.input = input; |
| this.location = location; |
| this.tokens = tokens; |
| this.inputLength = inputLength; |
| this.parseAction = parseAction; |
| this.errors = errors; |
| this.offset = offset; |
| this.rparensExpected = 0; |
| this.rbracketsExpected = 0; |
| this.rbracesExpected = 0; |
| this.index = 0; |
| } |
| _ParseAST.prototype.peek = function (offset) { |
| var i = this.index + offset; |
| return i < this.tokens.length ? this.tokens[i] : EOF; |
| }; |
| Object.defineProperty(_ParseAST.prototype, "next", { |
| get: function () { return this.peek(0); }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(_ParseAST.prototype, "inputIndex", { |
| get: function () { |
| return (this.index < this.tokens.length) ? this.next.index + this.offset : |
| this.inputLength + this.offset; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| _ParseAST.prototype.span = function (start) { return new ParseSpan(start, this.inputIndex); }; |
| _ParseAST.prototype.advance = function () { this.index++; }; |
| _ParseAST.prototype.optionalCharacter = function (code) { |
| if (this.next.isCharacter(code)) { |
| this.advance(); |
| return true; |
| } |
| else { |
| return false; |
| } |
| }; |
| _ParseAST.prototype.peekKeywordLet = function () { return this.next.isKeywordLet(); }; |
| _ParseAST.prototype.peekKeywordAs = function () { return this.next.isKeywordAs(); }; |
| _ParseAST.prototype.expectCharacter = function (code) { |
| if (this.optionalCharacter(code)) |
| return; |
| this.error("Missing expected " + String.fromCharCode(code)); |
| }; |
| _ParseAST.prototype.optionalOperator = function (op) { |
| if (this.next.isOperator(op)) { |
| this.advance(); |
| return true; |
| } |
| else { |
| return false; |
| } |
| }; |
| _ParseAST.prototype.expectOperator = function (operator) { |
| if (this.optionalOperator(operator)) |
| return; |
| this.error("Missing expected operator " + operator); |
| }; |
| _ParseAST.prototype.expectIdentifierOrKeyword = function () { |
| var n = this.next; |
| if (!n.isIdentifier() && !n.isKeyword()) { |
| this.error("Unexpected token " + n + ", expected identifier or keyword"); |
| return ''; |
| } |
| this.advance(); |
| return n.toString(); |
| }; |
| _ParseAST.prototype.expectIdentifierOrKeywordOrString = function () { |
| var n = this.next; |
| if (!n.isIdentifier() && !n.isKeyword() && !n.isString()) { |
| this.error("Unexpected token " + n + ", expected identifier, keyword, or string"); |
| return ''; |
| } |
| this.advance(); |
| return n.toString(); |
| }; |
| _ParseAST.prototype.parseChain = function () { |
| var exprs = []; |
| var start = this.inputIndex; |
| while (this.index < this.tokens.length) { |
| var expr = this.parsePipe(); |
| exprs.push(expr); |
| if (this.optionalCharacter($SEMICOLON)) { |
| if (!this.parseAction) { |
| this.error('Binding expression cannot contain chained expression'); |
| } |
| while (this.optionalCharacter($SEMICOLON)) { |
| } // read all semicolons |
| } |
| else if (this.index < this.tokens.length) { |
| this.error("Unexpected token '" + this.next + "'"); |
| } |
| } |
| if (exprs.length == 0) |
| return new EmptyExpr(this.span(start)); |
| if (exprs.length == 1) |
| return exprs[0]; |
| return new Chain(this.span(start), exprs); |
| }; |
| _ParseAST.prototype.parsePipe = function () { |
| var result = this.parseExpression(); |
| if (this.optionalOperator('|')) { |
| if (this.parseAction) { |
| this.error('Cannot have a pipe in an action expression'); |
| } |
| do { |
| var name_1 = this.expectIdentifierOrKeyword(); |
| var args = []; |
| while (this.optionalCharacter($COLON)) { |
| args.push(this.parseExpression()); |
| } |
| result = new BindingPipe(this.span(result.span.start), result, name_1, args); |
| } while (this.optionalOperator('|')); |
| } |
| return result; |
| }; |
| _ParseAST.prototype.parseExpression = function () { return this.parseConditional(); }; |
| _ParseAST.prototype.parseConditional = function () { |
| var start = this.inputIndex; |
| var result = this.parseLogicalOr(); |
| if (this.optionalOperator('?')) { |
| var yes = this.parsePipe(); |
| var no = void 0; |
| if (!this.optionalCharacter($COLON)) { |
| var end = this.inputIndex; |
| var expression = this.input.substring(start, end); |
| this.error("Conditional expression " + expression + " requires all 3 expressions"); |
| no = new EmptyExpr(this.span(start)); |
| } |
| else { |
| no = this.parsePipe(); |
| } |
| return new Conditional(this.span(start), result, yes, no); |
| } |
| else { |
| return result; |
| } |
| }; |
| _ParseAST.prototype.parseLogicalOr = function () { |
| // '||' |
| var result = this.parseLogicalAnd(); |
| while (this.optionalOperator('||')) { |
| var right = this.parseLogicalAnd(); |
| result = new Binary(this.span(result.span.start), '||', result, right); |
| } |
| return result; |
| }; |
| _ParseAST.prototype.parseLogicalAnd = function () { |
| // '&&' |
| var result = this.parseEquality(); |
| while (this.optionalOperator('&&')) { |
| var right = this.parseEquality(); |
| result = new Binary(this.span(result.span.start), '&&', result, right); |
| } |
| return result; |
| }; |
| _ParseAST.prototype.parseEquality = function () { |
| // '==','!=','===','!==' |
| var result = this.parseRelational(); |
| while (this.next.type == exports.TokenType.Operator) { |
| var operator = this.next.strValue; |
| switch (operator) { |
| case '==': |
| case '===': |
| case '!=': |
| case '!==': |
| this.advance(); |
| var right = this.parseRelational(); |
| result = new Binary(this.span(result.span.start), operator, result, right); |
| continue; |
| } |
| break; |
| } |
| return result; |
| }; |
| _ParseAST.prototype.parseRelational = function () { |
| // '<', '>', '<=', '>=' |
| var result = this.parseAdditive(); |
| while (this.next.type == exports.TokenType.Operator) { |
| var operator = this.next.strValue; |
| switch (operator) { |
| case '<': |
| case '>': |
| case '<=': |
| case '>=': |
| this.advance(); |
| var right = this.parseAdditive(); |
| result = new Binary(this.span(result.span.start), operator, result, right); |
| continue; |
| } |
| break; |
| } |
| return result; |
| }; |
| _ParseAST.prototype.parseAdditive = function () { |
| // '+', '-' |
| var result = this.parseMultiplicative(); |
| while (this.next.type == exports.TokenType.Operator) { |
| var operator = this.next.strValue; |
| switch (operator) { |
| case '+': |
| case '-': |
| this.advance(); |
| var right = this.parseMultiplicative(); |
| result = new Binary(this.span(result.span.start), operator, result, right); |
| continue; |
| } |
| break; |
| } |
| return result; |
| }; |
| _ParseAST.prototype.parseMultiplicative = function () { |
| // '*', '%', '/' |
| var result = this.parsePrefix(); |
| while (this.next.type == exports.TokenType.Operator) { |
| var operator = this.next.strValue; |
| switch (operator) { |
| case '*': |
| case '%': |
| case '/': |
| this.advance(); |
| var right = this.parsePrefix(); |
| result = new Binary(this.span(result.span.start), operator, result, right); |
| continue; |
| } |
| break; |
| } |
| return result; |
| }; |
| _ParseAST.prototype.parsePrefix = function () { |
| if (this.next.type == exports.TokenType.Operator) { |
| var start = this.inputIndex; |
| var operator = this.next.strValue; |
| var result = void 0; |
| switch (operator) { |
| case '+': |
| this.advance(); |
| result = this.parsePrefix(); |
| return new Binary(this.span(start), '-', result, new LiteralPrimitive(new ParseSpan(start, start), 0)); |
| case '-': |
| this.advance(); |
| result = this.parsePrefix(); |
| return new Binary(this.span(start), operator, new LiteralPrimitive(new ParseSpan(start, start), 0), result); |
| case '!': |
| this.advance(); |
| result = this.parsePrefix(); |
| return new PrefixNot(this.span(start), result); |
| } |
| } |
| return this.parseCallChain(); |
| }; |
| _ParseAST.prototype.parseCallChain = function () { |
| var result = this.parsePrimary(); |
| while (true) { |
| if (this.optionalCharacter($PERIOD)) { |
| result = this.parseAccessMemberOrMethodCall(result, false); |
| } |
| else if (this.optionalOperator('?.')) { |
| result = this.parseAccessMemberOrMethodCall(result, true); |
| } |
| else if (this.optionalCharacter($LBRACKET)) { |
| this.rbracketsExpected++; |
| var key = this.parsePipe(); |
| this.rbracketsExpected--; |
| this.expectCharacter($RBRACKET); |
| if (this.optionalOperator('=')) { |
| var value = this.parseConditional(); |
| result = new KeyedWrite(this.span(result.span.start), result, key, value); |
| } |
| else { |
| result = new KeyedRead(this.span(result.span.start), result, key); |
| } |
| } |
| else if (this.optionalCharacter($LPAREN)) { |
| this.rparensExpected++; |
| var args = this.parseCallArguments(); |
| this.rparensExpected--; |
| this.expectCharacter($RPAREN); |
| result = new FunctionCall(this.span(result.span.start), result, args); |
| } |
| else if (this.optionalOperator('!')) { |
| result = new NonNullAssert(this.span(result.span.start), result); |
| } |
| else { |
| return result; |
| } |
| } |
| }; |
| _ParseAST.prototype.parsePrimary = function () { |
| var start = this.inputIndex; |
| if (this.optionalCharacter($LPAREN)) { |
| this.rparensExpected++; |
| var result = this.parsePipe(); |
| this.rparensExpected--; |
| this.expectCharacter($RPAREN); |
| return result; |
| } |
| else if (this.next.isKeywordNull()) { |
| this.advance(); |
| return new LiteralPrimitive(this.span(start), null); |
| } |
| else if (this.next.isKeywordUndefined()) { |
| this.advance(); |
| return new LiteralPrimitive(this.span(start), void 0); |
| } |
| else if (this.next.isKeywordTrue()) { |
| this.advance(); |
| return new LiteralPrimitive(this.span(start), true); |
| } |
| else if (this.next.isKeywordFalse()) { |
| this.advance(); |
| return new LiteralPrimitive(this.span(start), false); |
| } |
| else if (this.next.isKeywordThis()) { |
| this.advance(); |
| return new ImplicitReceiver(this.span(start)); |
| } |
| else if (this.optionalCharacter($LBRACKET)) { |
| this.rbracketsExpected++; |
| var elements = this.parseExpressionList($RBRACKET); |
| this.rbracketsExpected--; |
| this.expectCharacter($RBRACKET); |
| return new LiteralArray(this.span(start), elements); |
| } |
| else if (this.next.isCharacter($LBRACE)) { |
| return this.parseLiteralMap(); |
| } |
| else if (this.next.isIdentifier()) { |
| return this.parseAccessMemberOrMethodCall(new ImplicitReceiver(this.span(start)), false); |
| } |
| else if (this.next.isNumber()) { |
| var value = this.next.toNumber(); |
| this.advance(); |
| return new LiteralPrimitive(this.span(start), value); |
| } |
| else if (this.next.isString()) { |
| var literalValue = this.next.toString(); |
| this.advance(); |
| return new LiteralPrimitive(this.span(start), literalValue); |
| } |
| else if (this.index >= this.tokens.length) { |
| this.error("Unexpected end of expression: " + this.input); |
| return new EmptyExpr(this.span(start)); |
| } |
| else { |
| this.error("Unexpected token " + this.next); |
| return new EmptyExpr(this.span(start)); |
| } |
| }; |
| _ParseAST.prototype.parseExpressionList = function (terminator) { |
| var result = []; |
| if (!this.next.isCharacter(terminator)) { |
| do { |
| result.push(this.parsePipe()); |
| } while (this.optionalCharacter($COMMA)); |
| } |
| return result; |
| }; |
| _ParseAST.prototype.parseLiteralMap = function () { |
| var keys = []; |
| var values = []; |
| var start = this.inputIndex; |
| this.expectCharacter($LBRACE); |
| if (!this.optionalCharacter($RBRACE)) { |
| this.rbracesExpected++; |
| do { |
| var quoted = this.next.isString(); |
| var key = this.expectIdentifierOrKeywordOrString(); |
| keys.push({ key: key, quoted: quoted }); |
| this.expectCharacter($COLON); |
| values.push(this.parsePipe()); |
| } while (this.optionalCharacter($COMMA)); |
| this.rbracesExpected--; |
| this.expectCharacter($RBRACE); |
| } |
| return new LiteralMap(this.span(start), keys, values); |
| }; |
| _ParseAST.prototype.parseAccessMemberOrMethodCall = function (receiver, isSafe) { |
| if (isSafe === void 0) { isSafe = false; } |
| var start = receiver.span.start; |
| var id = this.expectIdentifierOrKeyword(); |
| if (this.optionalCharacter($LPAREN)) { |
| this.rparensExpected++; |
| var args = this.parseCallArguments(); |
| this.expectCharacter($RPAREN); |
| this.rparensExpected--; |
| var span = this.span(start); |
| return isSafe ? new SafeMethodCall(span, receiver, id, args) : |
| new MethodCall(span, receiver, id, args); |
| } |
| else { |
| if (isSafe) { |
| if (this.optionalOperator('=')) { |
| this.error('The \'?.\' operator cannot be used in the assignment'); |
| return new EmptyExpr(this.span(start)); |
| } |
| else { |
| return new SafePropertyRead(this.span(start), receiver, id); |
| } |
| } |
| else { |
| if (this.optionalOperator('=')) { |
| if (!this.parseAction) { |
| this.error('Bindings cannot contain assignments'); |
| return new EmptyExpr(this.span(start)); |
| } |
| var value = this.parseConditional(); |
| return new PropertyWrite(this.span(start), receiver, id, value); |
| } |
| else { |
| return new PropertyRead(this.span(start), receiver, id); |
| } |
| } |
| } |
| }; |
| _ParseAST.prototype.parseCallArguments = function () { |
| if (this.next.isCharacter($RPAREN)) |
| return []; |
| var positionals = []; |
| do { |
| positionals.push(this.parsePipe()); |
| } while (this.optionalCharacter($COMMA)); |
| return positionals; |
| }; |
| /** |
| * An identifier, a keyword, a string with an optional `-` in between. |
| */ |
| _ParseAST.prototype.expectTemplateBindingKey = function () { |
| var result = ''; |
| var operatorFound = false; |
| do { |
| result += this.expectIdentifierOrKeywordOrString(); |
| operatorFound = this.optionalOperator('-'); |
| if (operatorFound) { |
| result += '-'; |
| } |
| } while (operatorFound); |
| return result.toString(); |
| }; |
| // Parses the AST for `<some-tag *tplKey=AST>` |
| _ParseAST.prototype.parseTemplateBindings = function (tplKey) { |
| var firstBinding = true; |
| var bindings = []; |
| var warnings = []; |
| do { |
| var start = this.inputIndex; |
| var rawKey = void 0; |
| var key = void 0; |
| var isVar = false; |
| if (firstBinding) { |
| rawKey = key = tplKey; |
| firstBinding = false; |
| } |
| else { |
| isVar = this.peekKeywordLet(); |
| if (isVar) |
| this.advance(); |
| rawKey = this.expectTemplateBindingKey(); |
| key = isVar ? rawKey : tplKey + rawKey[0].toUpperCase() + rawKey.substring(1); |
| this.optionalCharacter($COLON); |
| } |
| var name_2 = null; |
| var expression = null; |
| if (isVar) { |
| if (this.optionalOperator('=')) { |
| name_2 = this.expectTemplateBindingKey(); |
| } |
| else { |
| name_2 = '\$implicit'; |
| } |
| } |
| else if (this.peekKeywordAs()) { |
| this.advance(); // consume `as` |
| name_2 = rawKey; |
| key = this.expectTemplateBindingKey(); // read local var name |
| isVar = true; |
| } |
| else if (this.next !== EOF && !this.peekKeywordLet()) { |
| var start_1 = this.inputIndex; |
| var ast = this.parsePipe(); |
| var source = this.input.substring(start_1 - this.offset, this.inputIndex - this.offset); |
| expression = new ASTWithSource(ast, source, this.location, this.errors); |
| } |
| bindings.push(new TemplateBinding(this.span(start), key, isVar, name_2, expression)); |
| if (this.peekKeywordAs() && !isVar) { |
| var letStart = this.inputIndex; |
| this.advance(); // consume `as` |
| var letName = this.expectTemplateBindingKey(); // read local var name |
| bindings.push(new TemplateBinding(this.span(letStart), letName, true, key, null)); |
| } |
| if (!this.optionalCharacter($SEMICOLON)) { |
| this.optionalCharacter($COMMA); |
| } |
| } while (this.index < this.tokens.length); |
| return new TemplateBindingParseResult(bindings, warnings, this.errors); |
| }; |
| _ParseAST.prototype.error = function (message, index) { |
| if (index === void 0) { index = null; } |
| this.errors.push(new ParserError(message, this.input, this.locationText(index), this.location)); |
| this.skip(); |
| }; |
| _ParseAST.prototype.locationText = function (index) { |
| if (index === void 0) { index = null; } |
| if (index == null) |
| index = this.index; |
| return (index < this.tokens.length) ? "at column " + (this.tokens[index].index + 1) + " in" : |
| "at the end of the expression"; |
| }; |
| // Error recovery should skip tokens until it encounters a recovery point. skip() treats |
| // the end of input and a ';' as unconditionally a recovery point. It also treats ')', |
| // '}' and ']' as conditional recovery points if one of calling productions is expecting |
| // one of these symbols. This allows skip() to recover from errors such as '(a.) + 1' allowing |
| // more of the AST to be retained (it doesn't skip any tokens as the ')' is retained because |
| // of the '(' begins an '(' <expr> ')' production). The recovery points of grouping symbols |
| // must be conditional as they must be skipped if none of the calling productions are not |
| // expecting the closing token else we will never make progress in the case of an |
| // extraneous group closing symbol (such as a stray ')'). This is not the case for ';' because |
| // parseChain() is always the root production and it expects a ';'. |
| // If a production expects one of these token it increments the corresponding nesting count, |
| // and then decrements it just prior to checking if the token is in the input. |
| _ParseAST.prototype.skip = function () { |
| var n = this.next; |
| while (this.index < this.tokens.length && !n.isCharacter($SEMICOLON) && |
| (this.rparensExpected <= 0 || !n.isCharacter($RPAREN)) && |
| (this.rbracesExpected <= 0 || !n.isCharacter($RBRACE)) && |
| (this.rbracketsExpected <= 0 || !n.isCharacter($RBRACKET))) { |
| if (this.next.isError()) { |
| this.errors.push(new ParserError(this.next.toString(), this.input, this.locationText(), this.location)); |
| } |
| this.advance(); |
| n = this.next; |
| } |
| }; |
| return _ParseAST; |
| }()); |
| var SimpleExpressionChecker = /** @class */ (function () { |
| function SimpleExpressionChecker() { |
| this.errors = []; |
| } |
| SimpleExpressionChecker.check = function (ast) { |
| var s = new SimpleExpressionChecker(); |
| ast.visit(s); |
| return s.errors; |
| }; |
| SimpleExpressionChecker.prototype.visitImplicitReceiver = function (ast, context) { }; |
| SimpleExpressionChecker.prototype.visitInterpolation = function (ast, context) { }; |
| SimpleExpressionChecker.prototype.visitLiteralPrimitive = function (ast, context) { }; |
| SimpleExpressionChecker.prototype.visitPropertyRead = function (ast, context) { }; |
| SimpleExpressionChecker.prototype.visitPropertyWrite = function (ast, context) { }; |
| SimpleExpressionChecker.prototype.visitSafePropertyRead = function (ast, context) { }; |
| SimpleExpressionChecker.prototype.visitMethodCall = function (ast, context) { }; |
| SimpleExpressionChecker.prototype.visitSafeMethodCall = function (ast, context) { }; |
| SimpleExpressionChecker.prototype.visitFunctionCall = function (ast, context) { }; |
| SimpleExpressionChecker.prototype.visitLiteralArray = function (ast, context) { this.visitAll(ast.expressions); }; |
| SimpleExpressionChecker.prototype.visitLiteralMap = function (ast, context) { this.visitAll(ast.values); }; |
| SimpleExpressionChecker.prototype.visitBinary = function (ast, context) { }; |
| SimpleExpressionChecker.prototype.visitPrefixNot = function (ast, context) { }; |
| SimpleExpressionChecker.prototype.visitNonNullAssert = function (ast, context) { }; |
| SimpleExpressionChecker.prototype.visitConditional = function (ast, context) { }; |
| SimpleExpressionChecker.prototype.visitPipe = function (ast, context) { this.errors.push('pipes'); }; |
| SimpleExpressionChecker.prototype.visitKeyedRead = function (ast, context) { }; |
| SimpleExpressionChecker.prototype.visitKeyedWrite = function (ast, context) { }; |
| SimpleExpressionChecker.prototype.visitAll = function (asts) { |
| var _this = this; |
| return asts.map(function (node) { return node.visit(_this); }); |
| }; |
| SimpleExpressionChecker.prototype.visitChain = function (ast, context) { }; |
| SimpleExpressionChecker.prototype.visitQuote = function (ast, context) { }; |
| return SimpleExpressionChecker; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| // ================================================================================================= |
| // ================================================================================================= |
| // =========== S T O P - S T O P - S T O P - S T O P - S T O P - S T O P =========== |
| // ================================================================================================= |
| // ================================================================================================= |
| // |
| // DO NOT EDIT THIS LIST OF SECURITY SENSITIVE PROPERTIES WITHOUT A SECURITY REVIEW! |
| // Reach out to mprobst for details. |
| // |
| // ================================================================================================= |
| /** Map from tagName|propertyName SecurityContext. Properties applying to all tags use '*'. */ |
| var _SECURITY_SCHEMA; |
| function SECURITY_SCHEMA() { |
| if (!_SECURITY_SCHEMA) { |
| _SECURITY_SCHEMA = {}; |
| // Case is insignificant below, all element and attribute names are lower-cased for lookup. |
| registerContext(SecurityContext.HTML, [ |
| 'iframe|srcdoc', |
| '*|innerHTML', |
| '*|outerHTML', |
| ]); |
| registerContext(SecurityContext.STYLE, ['*|style']); |
| // NB: no SCRIPT contexts here, they are never allowed due to the parser stripping them. |
| registerContext(SecurityContext.URL, [ |
| '*|formAction', 'area|href', 'area|ping', 'audio|src', 'a|href', |
| 'a|ping', 'blockquote|cite', 'body|background', 'del|cite', 'form|action', |
| 'img|src', 'img|srcset', 'input|src', 'ins|cite', 'q|cite', |
| 'source|src', 'source|srcset', 'track|src', 'video|poster', 'video|src', |
| ]); |
| registerContext(SecurityContext.RESOURCE_URL, [ |
| 'applet|code', |
| 'applet|codebase', |
| 'base|href', |
| 'embed|src', |
| 'frame|src', |
| 'head|profile', |
| 'html|manifest', |
| 'iframe|src', |
| 'link|href', |
| 'media|src', |
| 'object|codebase', |
| 'object|data', |
| 'script|src', |
| ]); |
| } |
| return _SECURITY_SCHEMA; |
| } |
| function registerContext(ctx, specs) { |
| var e_1, _a; |
| try { |
| for (var specs_1 = __values(specs), specs_1_1 = specs_1.next(); !specs_1_1.done; specs_1_1 = specs_1.next()) { |
| var spec = specs_1_1.value; |
| _SECURITY_SCHEMA[spec.toLowerCase()] = ctx; |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (specs_1_1 && !specs_1_1.done && (_a = specs_1.return)) _a.call(specs_1); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var ElementSchemaRegistry = /** @class */ (function () { |
| function ElementSchemaRegistry() { |
| } |
| return ElementSchemaRegistry; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var BOOLEAN = 'boolean'; |
| var NUMBER = 'number'; |
| var STRING = 'string'; |
| var OBJECT = 'object'; |
| /** |
| * This array represents the DOM schema. It encodes inheritance, properties, and events. |
| * |
| * ## Overview |
| * |
| * Each line represents one kind of element. The `element_inheritance` and properties are joined |
| * using `element_inheritance|properties` syntax. |
| * |
| * ## Element Inheritance |
| * |
| * The `element_inheritance` can be further subdivided as `element1,element2,...^parentElement`. |
| * Here the individual elements are separated by `,` (commas). Every element in the list |
| * has identical properties. |
| * |
| * An `element` may inherit additional properties from `parentElement` If no `^parentElement` is |
| * specified then `""` (blank) element is assumed. |
| * |
| * NOTE: The blank element inherits from root `[Element]` element, the super element of all |
| * elements. |
| * |
| * NOTE an element prefix such as `:svg:` has no special meaning to the schema. |
| * |
| * ## Properties |
| * |
| * Each element has a set of properties separated by `,` (commas). Each property can be prefixed |
| * by a special character designating its type: |
| * |
| * - (no prefix): property is a string. |
| * - `*`: property represents an event. |
| * - `!`: property is a boolean. |
| * - `#`: property is a number. |
| * - `%`: property is an object. |
| * |
| * ## Query |
| * |
| * The class creates an internal squas representation which allows to easily answer the query of |
| * if a given property exist on a given element. |
| * |
| * NOTE: We don't yet support querying for types or events. |
| * NOTE: This schema is auto extracted from `schema_extractor.ts` located in the test folder, |
| * see dom_element_schema_registry_spec.ts |
| */ |
| // ================================================================================================= |
| // ================================================================================================= |
| // =========== S T O P - S T O P - S T O P - S T O P - S T O P - S T O P =========== |
| // ================================================================================================= |
| // ================================================================================================= |
| // |
| // DO NOT EDIT THIS DOM SCHEMA WITHOUT A SECURITY REVIEW! |
| // |
| // Newly added properties must be security reviewed and assigned an appropriate SecurityContext in |
| // dom_security_schema.ts. Reach out to mprobst & rjamet for details. |
| // |
| // ================================================================================================= |
| var SCHEMA = [ |
| '[Element]|textContent,%classList,className,id,innerHTML,*beforecopy,*beforecut,*beforepaste,*copy,*cut,*paste,*search,*selectstart,*webkitfullscreenchange,*webkitfullscreenerror,*wheel,outerHTML,#scrollLeft,#scrollTop,slot' + |
| /* added manually to avoid breaking changes */ |
| ',*message,*mozfullscreenchange,*mozfullscreenerror,*mozpointerlockchange,*mozpointerlockerror,*webglcontextcreationerror,*webglcontextlost,*webglcontextrestored', |
| '[HTMLElement]^[Element]|accessKey,contentEditable,dir,!draggable,!hidden,innerText,lang,*abort,*auxclick,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*gotpointercapture,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*lostpointercapture,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*pointercancel,*pointerdown,*pointerenter,*pointerleave,*pointermove,*pointerout,*pointerover,*pointerup,*progress,*ratechange,*reset,*resize,*scroll,*seeked,*seeking,*select,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,outerText,!spellcheck,%style,#tabIndex,title,!translate', |
| 'abbr,address,article,aside,b,bdi,bdo,cite,code,dd,dfn,dt,em,figcaption,figure,footer,header,i,kbd,main,mark,nav,noscript,rb,rp,rt,rtc,ruby,s,samp,section,small,strong,sub,sup,u,var,wbr^[HTMLElement]|accessKey,contentEditable,dir,!draggable,!hidden,innerText,lang,*abort,*auxclick,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*gotpointercapture,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*lostpointercapture,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*pointercancel,*pointerdown,*pointerenter,*pointerleave,*pointermove,*pointerout,*pointerover,*pointerup,*progress,*ratechange,*reset,*resize,*scroll,*seeked,*seeking,*select,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,outerText,!spellcheck,%style,#tabIndex,title,!translate', |
| 'media^[HTMLElement]|!autoplay,!controls,%controlsList,%crossOrigin,#currentTime,!defaultMuted,#defaultPlaybackRate,!disableRemotePlayback,!loop,!muted,*encrypted,*waitingforkey,#playbackRate,preload,src,%srcObject,#volume', |
| ':svg:^[HTMLElement]|*abort,*auxclick,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*cuechange,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*gotpointercapture,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*lostpointercapture,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*pause,*play,*playing,*pointercancel,*pointerdown,*pointerenter,*pointerleave,*pointermove,*pointerout,*pointerover,*pointerup,*progress,*ratechange,*reset,*resize,*scroll,*seeked,*seeking,*select,*show,*stalled,*submit,*suspend,*timeupdate,*toggle,*volumechange,*waiting,%style,#tabIndex', |
| ':svg:graphics^:svg:|', |
| ':svg:animation^:svg:|*begin,*end,*repeat', |
| ':svg:geometry^:svg:|', |
| ':svg:componentTransferFunction^:svg:|', |
| ':svg:gradient^:svg:|', |
| ':svg:textContent^:svg:graphics|', |
| ':svg:textPositioning^:svg:textContent|', |
| 'a^[HTMLElement]|charset,coords,download,hash,host,hostname,href,hreflang,name,password,pathname,ping,port,protocol,referrerPolicy,rel,rev,search,shape,target,text,type,username', |
| 'area^[HTMLElement]|alt,coords,download,hash,host,hostname,href,!noHref,password,pathname,ping,port,protocol,referrerPolicy,rel,search,shape,target,username', |
| 'audio^media|', |
| 'br^[HTMLElement]|clear', |
| 'base^[HTMLElement]|href,target', |
| 'body^[HTMLElement]|aLink,background,bgColor,link,*beforeunload,*blur,*error,*focus,*hashchange,*languagechange,*load,*message,*offline,*online,*pagehide,*pageshow,*popstate,*rejectionhandled,*resize,*scroll,*storage,*unhandledrejection,*unload,text,vLink', |
| 'button^[HTMLElement]|!autofocus,!disabled,formAction,formEnctype,formMethod,!formNoValidate,formTarget,name,type,value', |
| 'canvas^[HTMLElement]|#height,#width', |
| 'content^[HTMLElement]|select', |
| 'dl^[HTMLElement]|!compact', |
| 'datalist^[HTMLElement]|', |
| 'details^[HTMLElement]|!open', |
| 'dialog^[HTMLElement]|!open,returnValue', |
| 'dir^[HTMLElement]|!compact', |
| 'div^[HTMLElement]|align', |
| 'embed^[HTMLElement]|align,height,name,src,type,width', |
| 'fieldset^[HTMLElement]|!disabled,name', |
| 'font^[HTMLElement]|color,face,size', |
| 'form^[HTMLElement]|acceptCharset,action,autocomplete,encoding,enctype,method,name,!noValidate,target', |
| 'frame^[HTMLElement]|frameBorder,longDesc,marginHeight,marginWidth,name,!noResize,scrolling,src', |
| 'frameset^[HTMLElement]|cols,*beforeunload,*blur,*error,*focus,*hashchange,*languagechange,*load,*message,*offline,*online,*pagehide,*pageshow,*popstate,*rejectionhandled,*resize,*scroll,*storage,*unhandledrejection,*unload,rows', |
| 'hr^[HTMLElement]|align,color,!noShade,size,width', |
| 'head^[HTMLElement]|', |
| 'h1,h2,h3,h4,h5,h6^[HTMLElement]|align', |
| 'html^[HTMLElement]|version', |
| 'iframe^[HTMLElement]|align,!allowFullscreen,frameBorder,height,longDesc,marginHeight,marginWidth,name,referrerPolicy,%sandbox,scrolling,src,srcdoc,width', |
| 'img^[HTMLElement]|align,alt,border,%crossOrigin,#height,#hspace,!isMap,longDesc,lowsrc,name,referrerPolicy,sizes,src,srcset,useMap,#vspace,#width', |
| 'input^[HTMLElement]|accept,align,alt,autocapitalize,autocomplete,!autofocus,!checked,!defaultChecked,defaultValue,dirName,!disabled,%files,formAction,formEnctype,formMethod,!formNoValidate,formTarget,#height,!incremental,!indeterminate,max,#maxLength,min,#minLength,!multiple,name,pattern,placeholder,!readOnly,!required,selectionDirection,#selectionEnd,#selectionStart,#size,src,step,type,useMap,value,%valueAsDate,#valueAsNumber,#width', |
| 'li^[HTMLElement]|type,#value', |
| 'label^[HTMLElement]|htmlFor', |
| 'legend^[HTMLElement]|align', |
| 'link^[HTMLElement]|as,charset,%crossOrigin,!disabled,href,hreflang,integrity,media,referrerPolicy,rel,%relList,rev,%sizes,target,type', |
| 'map^[HTMLElement]|name', |
| 'marquee^[HTMLElement]|behavior,bgColor,direction,height,#hspace,#loop,#scrollAmount,#scrollDelay,!trueSpeed,#vspace,width', |
| 'menu^[HTMLElement]|!compact', |
| 'meta^[HTMLElement]|content,httpEquiv,name,scheme', |
| 'meter^[HTMLElement]|#high,#low,#max,#min,#optimum,#value', |
| 'ins,del^[HTMLElement]|cite,dateTime', |
| 'ol^[HTMLElement]|!compact,!reversed,#start,type', |
| 'object^[HTMLElement]|align,archive,border,code,codeBase,codeType,data,!declare,height,#hspace,name,standby,type,useMap,#vspace,width', |
| 'optgroup^[HTMLElement]|!disabled,label', |
| 'option^[HTMLElement]|!defaultSelected,!disabled,label,!selected,text,value', |
| 'output^[HTMLElement]|defaultValue,%htmlFor,name,value', |
| 'p^[HTMLElement]|align', |
| 'param^[HTMLElement]|name,type,value,valueType', |
| 'picture^[HTMLElement]|', |
| 'pre^[HTMLElement]|#width', |
| 'progress^[HTMLElement]|#max,#value', |
| 'q,blockquote,cite^[HTMLElement]|', |
| 'script^[HTMLElement]|!async,charset,%crossOrigin,!defer,event,htmlFor,integrity,src,text,type', |
| 'select^[HTMLElement]|!autofocus,!disabled,#length,!multiple,name,!required,#selectedIndex,#size,value', |
| 'shadow^[HTMLElement]|', |
| 'slot^[HTMLElement]|name', |
| 'source^[HTMLElement]|media,sizes,src,srcset,type', |
| 'span^[HTMLElement]|', |
| 'style^[HTMLElement]|!disabled,media,type', |
| 'caption^[HTMLElement]|align', |
| 'th,td^[HTMLElement]|abbr,align,axis,bgColor,ch,chOff,#colSpan,headers,height,!noWrap,#rowSpan,scope,vAlign,width', |
| 'col,colgroup^[HTMLElement]|align,ch,chOff,#span,vAlign,width', |
| 'table^[HTMLElement]|align,bgColor,border,%caption,cellPadding,cellSpacing,frame,rules,summary,%tFoot,%tHead,width', |
| 'tr^[HTMLElement]|align,bgColor,ch,chOff,vAlign', |
| 'tfoot,thead,tbody^[HTMLElement]|align,ch,chOff,vAlign', |
| 'template^[HTMLElement]|', |
| 'textarea^[HTMLElement]|autocapitalize,!autofocus,#cols,defaultValue,dirName,!disabled,#maxLength,#minLength,name,placeholder,!readOnly,!required,#rows,selectionDirection,#selectionEnd,#selectionStart,value,wrap', |
| 'title^[HTMLElement]|text', |
| 'track^[HTMLElement]|!default,kind,label,src,srclang', |
| 'ul^[HTMLElement]|!compact,type', |
| 'unknown^[HTMLElement]|', |
| 'video^media|#height,poster,#width', |
| ':svg:a^:svg:graphics|', |
| ':svg:animate^:svg:animation|', |
| ':svg:animateMotion^:svg:animation|', |
| ':svg:animateTransform^:svg:animation|', |
| ':svg:circle^:svg:geometry|', |
| ':svg:clipPath^:svg:graphics|', |
| ':svg:defs^:svg:graphics|', |
| ':svg:desc^:svg:|', |
| ':svg:discard^:svg:|', |
| ':svg:ellipse^:svg:geometry|', |
| ':svg:feBlend^:svg:|', |
| ':svg:feColorMatrix^:svg:|', |
| ':svg:feComponentTransfer^:svg:|', |
| ':svg:feComposite^:svg:|', |
| ':svg:feConvolveMatrix^:svg:|', |
| ':svg:feDiffuseLighting^:svg:|', |
| ':svg:feDisplacementMap^:svg:|', |
| ':svg:feDistantLight^:svg:|', |
| ':svg:feDropShadow^:svg:|', |
| ':svg:feFlood^:svg:|', |
| ':svg:feFuncA^:svg:componentTransferFunction|', |
| ':svg:feFuncB^:svg:componentTransferFunction|', |
| ':svg:feFuncG^:svg:componentTransferFunction|', |
| ':svg:feFuncR^:svg:componentTransferFunction|', |
| ':svg:feGaussianBlur^:svg:|', |
| ':svg:feImage^:svg:|', |
| ':svg:feMerge^:svg:|', |
| ':svg:feMergeNode^:svg:|', |
| ':svg:feMorphology^:svg:|', |
| ':svg:feOffset^:svg:|', |
| ':svg:fePointLight^:svg:|', |
| ':svg:feSpecularLighting^:svg:|', |
| ':svg:feSpotLight^:svg:|', |
| ':svg:feTile^:svg:|', |
| ':svg:feTurbulence^:svg:|', |
| ':svg:filter^:svg:|', |
| ':svg:foreignObject^:svg:graphics|', |
| ':svg:g^:svg:graphics|', |
| ':svg:image^:svg:graphics|', |
| ':svg:line^:svg:geometry|', |
| ':svg:linearGradient^:svg:gradient|', |
| ':svg:mpath^:svg:|', |
| ':svg:marker^:svg:|', |
| ':svg:mask^:svg:|', |
| ':svg:metadata^:svg:|', |
| ':svg:path^:svg:geometry|', |
| ':svg:pattern^:svg:|', |
| ':svg:polygon^:svg:geometry|', |
| ':svg:polyline^:svg:geometry|', |
| ':svg:radialGradient^:svg:gradient|', |
| ':svg:rect^:svg:geometry|', |
| ':svg:svg^:svg:graphics|#currentScale,#zoomAndPan', |
| ':svg:script^:svg:|type', |
| ':svg:set^:svg:animation|', |
| ':svg:stop^:svg:|', |
| ':svg:style^:svg:|!disabled,media,title,type', |
| ':svg:switch^:svg:graphics|', |
| ':svg:symbol^:svg:|', |
| ':svg:tspan^:svg:textPositioning|', |
| ':svg:text^:svg:textPositioning|', |
| ':svg:textPath^:svg:textContent|', |
| ':svg:title^:svg:|', |
| ':svg:use^:svg:graphics|', |
| ':svg:view^:svg:|#zoomAndPan', |
| 'data^[HTMLElement]|value', |
| 'keygen^[HTMLElement]|!autofocus,challenge,!disabled,form,keytype,name', |
| 'menuitem^[HTMLElement]|type,label,icon,!disabled,!checked,radiogroup,!default', |
| 'summary^[HTMLElement]|', |
| 'time^[HTMLElement]|dateTime', |
| ':svg:cursor^:svg:|', |
| ]; |
| var _ATTR_TO_PROP = { |
| 'class': 'className', |
| 'for': 'htmlFor', |
| 'formaction': 'formAction', |
| 'innerHtml': 'innerHTML', |
| 'readonly': 'readOnly', |
| 'tabindex': 'tabIndex', |
| }; |
| var DomElementSchemaRegistry = /** @class */ (function (_super) { |
| __extends(DomElementSchemaRegistry, _super); |
| function DomElementSchemaRegistry() { |
| var _this = _super.call(this) || this; |
| _this._schema = {}; |
| SCHEMA.forEach(function (encodedType) { |
| var type = {}; |
| var _a = __read(encodedType.split('|'), 2), strType = _a[0], strProperties = _a[1]; |
| var properties = strProperties.split(','); |
| var _b = __read(strType.split('^'), 2), typeNames = _b[0], superName = _b[1]; |
| typeNames.split(',').forEach(function (tag) { return _this._schema[tag.toLowerCase()] = type; }); |
| var superType = superName && _this._schema[superName.toLowerCase()]; |
| if (superType) { |
| Object.keys(superType).forEach(function (prop) { type[prop] = superType[prop]; }); |
| } |
| properties.forEach(function (property) { |
| if (property.length > 0) { |
| switch (property[0]) { |
| case '*': |
| // We don't yet support events. |
| // If ever allowing to bind to events, GO THROUGH A SECURITY REVIEW, allowing events |
| // will |
| // almost certainly introduce bad XSS vulnerabilities. |
| // type[property.substring(1)] = EVENT; |
| break; |
| case '!': |
| type[property.substring(1)] = BOOLEAN; |
| break; |
| case '#': |
| type[property.substring(1)] = NUMBER; |
| break; |
| case '%': |
| type[property.substring(1)] = OBJECT; |
| break; |
| default: |
| type[property] = STRING; |
| } |
| } |
| }); |
| }); |
| return _this; |
| } |
| DomElementSchemaRegistry.prototype.hasProperty = function (tagName, propName, schemaMetas) { |
| if (schemaMetas.some(function (schema) { return schema.name === NO_ERRORS_SCHEMA.name; })) { |
| return true; |
| } |
| if (tagName.indexOf('-') > -1) { |
| if (isNgContainer(tagName) || isNgContent(tagName)) { |
| return false; |
| } |
| if (schemaMetas.some(function (schema) { return schema.name === CUSTOM_ELEMENTS_SCHEMA.name; })) { |
| // Can't tell now as we don't know which properties a custom element will get |
| // once it is instantiated |
| return true; |
| } |
| } |
| var elementProperties = this._schema[tagName.toLowerCase()] || this._schema['unknown']; |
| return !!elementProperties[propName]; |
| }; |
| DomElementSchemaRegistry.prototype.hasElement = function (tagName, schemaMetas) { |
| if (schemaMetas.some(function (schema) { return schema.name === NO_ERRORS_SCHEMA.name; })) { |
| return true; |
| } |
| if (tagName.indexOf('-') > -1) { |
| if (isNgContainer(tagName) || isNgContent(tagName)) { |
| return true; |
| } |
| if (schemaMetas.some(function (schema) { return schema.name === CUSTOM_ELEMENTS_SCHEMA.name; })) { |
| // Allow any custom elements |
| return true; |
| } |
| } |
| return !!this._schema[tagName.toLowerCase()]; |
| }; |
| /** |
| * securityContext returns the security context for the given property on the given DOM tag. |
| * |
| * Tag and property name are statically known and cannot change at runtime, i.e. it is not |
| * possible to bind a value into a changing attribute or tag name. |
| * |
| * The filtering is based on a list of allowed tags|attributes. All attributes in the schema |
| * above are assumed to have the 'NONE' security context, i.e. that they are safe inert |
| * string values. Only specific well known attack vectors are assigned their appropriate context. |
| */ |
| DomElementSchemaRegistry.prototype.securityContext = function (tagName, propName, isAttribute) { |
| if (isAttribute) { |
| // NB: For security purposes, use the mapped property name, not the attribute name. |
| propName = this.getMappedPropName(propName); |
| } |
| // Make sure comparisons are case insensitive, so that case differences between attribute and |
| // property names do not have a security impact. |
| tagName = tagName.toLowerCase(); |
| propName = propName.toLowerCase(); |
| var ctx = SECURITY_SCHEMA()[tagName + '|' + propName]; |
| if (ctx) { |
| return ctx; |
| } |
| ctx = SECURITY_SCHEMA()['*|' + propName]; |
| return ctx ? ctx : SecurityContext.NONE; |
| }; |
| DomElementSchemaRegistry.prototype.getMappedPropName = function (propName) { return _ATTR_TO_PROP[propName] || propName; }; |
| DomElementSchemaRegistry.prototype.getDefaultComponentElementName = function () { return 'ng-component'; }; |
| DomElementSchemaRegistry.prototype.validateProperty = function (name) { |
| if (name.toLowerCase().startsWith('on')) { |
| var msg = "Binding to event property '" + name + "' is disallowed for security reasons, " + |
| ("please use (" + name.slice(2) + ")=...") + |
| ("\nIf '" + name + "' is a directive input, make sure the directive is imported by the") + |
| " current module."; |
| return { error: true, msg: msg }; |
| } |
| else { |
| return { error: false }; |
| } |
| }; |
| DomElementSchemaRegistry.prototype.validateAttribute = function (name) { |
| if (name.toLowerCase().startsWith('on')) { |
| var msg = "Binding to event attribute '" + name + "' is disallowed for security reasons, " + |
| ("please use (" + name.slice(2) + ")=..."); |
| return { error: true, msg: msg }; |
| } |
| else { |
| return { error: false }; |
| } |
| }; |
| DomElementSchemaRegistry.prototype.allKnownElementNames = function () { return Object.keys(this._schema); }; |
| DomElementSchemaRegistry.prototype.normalizeAnimationStyleProperty = function (propName) { |
| return dashCaseToCamelCase(propName); |
| }; |
| DomElementSchemaRegistry.prototype.normalizeAnimationStyleValue = function (camelCaseProp, userProvidedProp, val) { |
| var unit = ''; |
| var strVal = val.toString().trim(); |
| var errorMsg = null; |
| if (_isPixelDimensionStyle(camelCaseProp) && val !== 0 && val !== '0') { |
| if (typeof val === 'number') { |
| unit = 'px'; |
| } |
| else { |
| var valAndSuffixMatch = val.match(/^[+-]?[\d\.]+([a-z]*)$/); |
| if (valAndSuffixMatch && valAndSuffixMatch[1].length == 0) { |
| errorMsg = "Please provide a CSS unit value for " + userProvidedProp + ":" + val; |
| } |
| } |
| } |
| return { error: errorMsg, value: strVal + unit }; |
| }; |
| return DomElementSchemaRegistry; |
| }(ElementSchemaRegistry)); |
| function _isPixelDimensionStyle(prop) { |
| switch (prop) { |
| case 'width': |
| case 'height': |
| case 'minWidth': |
| case 'minHeight': |
| case 'maxWidth': |
| case 'maxHeight': |
| case 'left': |
| case 'top': |
| case 'bottom': |
| case 'right': |
| case 'fontSize': |
| case 'outlineWidth': |
| case 'outlineOffset': |
| case 'paddingTop': |
| case 'paddingLeft': |
| case 'paddingBottom': |
| case 'paddingRight': |
| case 'marginTop': |
| case 'marginLeft': |
| case 'marginBottom': |
| case 'marginRight': |
| case 'borderRadius': |
| case 'borderWidth': |
| case 'borderTopWidth': |
| case 'borderLeftWidth': |
| case 'borderRightWidth': |
| case 'borderBottomWidth': |
| case 'textIndent': |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var BIND_NAME_REGEXP$1 = /^(?:(?:(?:(bind-)|(let-)|(ref-|#)|(on-)|(bindon-)|(@))(.+))|\[\(([^\)]+)\)\]|\[([^\]]+)\]|\(([^\)]+)\))$/; |
| // Group 1 = "bind-" |
| var KW_BIND_IDX$1 = 1; |
| // Group 2 = "let-" |
| var KW_LET_IDX$1 = 2; |
| // Group 3 = "ref-/#" |
| var KW_REF_IDX$1 = 3; |
| // Group 4 = "on-" |
| var KW_ON_IDX$1 = 4; |
| // Group 5 = "bindon-" |
| var KW_BINDON_IDX$1 = 5; |
| // Group 6 = "@" |
| var KW_AT_IDX$1 = 6; |
| // Group 7 = the identifier after "bind-", "let-", "ref-/#", "on-", "bindon-" or "@" |
| var IDENT_KW_IDX$1 = 7; |
| // Group 8 = identifier inside [()] |
| var IDENT_BANANA_BOX_IDX$1 = 8; |
| // Group 9 = identifier inside [] |
| var IDENT_PROPERTY_IDX$1 = 9; |
| // Group 10 = identifier inside () |
| var IDENT_EVENT_IDX$1 = 10; |
| var TEMPLATE_ATTR_PREFIX$1 = '*'; |
| function htmlAstToRender3Ast(htmlNodes, bindingParser) { |
| var transformer = new HtmlAstToIvyAst(bindingParser); |
| var ivyNodes = visitAll$1(transformer, htmlNodes); |
| // Errors might originate in either the binding parser or the html to ivy transformer |
| var allErrors = bindingParser.errors.concat(transformer.errors); |
| var errors = allErrors.filter(function (e) { return e.level === exports.ParseErrorLevel.ERROR; }); |
| if (errors.length > 0) { |
| var errorString = errors.join('\n'); |
| throw syntaxError("Template parse errors:\n" + errorString, errors); |
| } |
| return { |
| nodes: ivyNodes, |
| errors: allErrors, |
| styleUrls: transformer.styleUrls, |
| styles: transformer.styles, |
| }; |
| } |
| var HtmlAstToIvyAst = /** @class */ (function () { |
| function HtmlAstToIvyAst(bindingParser) { |
| this.bindingParser = bindingParser; |
| this.errors = []; |
| this.styles = []; |
| this.styleUrls = []; |
| } |
| // HTML visitor |
| HtmlAstToIvyAst.prototype.visitElement = function (element) { |
| var _this = this; |
| var e_1, _a; |
| var preparsedElement = preparseElement(element); |
| if (preparsedElement.type === PreparsedElementType.SCRIPT) { |
| return null; |
| } |
| else if (preparsedElement.type === PreparsedElementType.STYLE) { |
| var contents = textContents(element); |
| if (contents !== null) { |
| this.styles.push(contents); |
| } |
| return null; |
| } |
| else if (preparsedElement.type === PreparsedElementType.STYLESHEET && |
| isStyleUrlResolvable(preparsedElement.hrefAttr)) { |
| this.styleUrls.push(preparsedElement.hrefAttr); |
| return null; |
| } |
| // Whether the element is a `<ng-template>` |
| var isTemplateElement = isNgTemplate(element.name); |
| var parsedProperties = []; |
| var boundEvents = []; |
| var variables = []; |
| var references = []; |
| var attributes = []; |
| var i18nAttrsMeta = {}; |
| var templateParsedProperties = []; |
| var templateVariables = []; |
| // Whether the element has any *-attribute |
| var elementHasInlineTemplate = false; |
| try { |
| for (var _b = __values(element.attrs), _c = _b.next(); !_c.done; _c = _b.next()) { |
| var attribute = _c.value; |
| var hasBinding = false; |
| var normalizedName = normalizeAttributeName(attribute.name); |
| // `*attr` defines template bindings |
| var isTemplateBinding = false; |
| if (attribute.i18n) { |
| i18nAttrsMeta[attribute.name] = attribute.i18n; |
| } |
| if (normalizedName.startsWith(TEMPLATE_ATTR_PREFIX$1)) { |
| // *-attributes |
| if (elementHasInlineTemplate) { |
| this.reportError("Can't have multiple template bindings on one element. Use only one attribute prefixed with *", attribute.sourceSpan); |
| } |
| isTemplateBinding = true; |
| elementHasInlineTemplate = true; |
| var templateValue = attribute.value; |
| var templateKey = normalizedName.substring(TEMPLATE_ATTR_PREFIX$1.length); |
| var parsedVariables = []; |
| this.bindingParser.parseInlineTemplateBinding(templateKey, templateValue, attribute.sourceSpan, [], templateParsedProperties, parsedVariables); |
| templateVariables.push.apply(templateVariables, __spread(parsedVariables.map(function (v) { return new Variable(v.name, v.value, v.sourceSpan); }))); |
| } |
| else { |
| // Check for variables, events, property bindings, interpolation |
| hasBinding = this.parseAttribute(isTemplateElement, attribute, [], parsedProperties, boundEvents, variables, references); |
| } |
| if (!hasBinding && !isTemplateBinding) { |
| // don't include the bindings as attributes as well in the AST |
| attributes.push(this.visitAttribute(attribute)); |
| } |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (_c && !_c.done && (_a = _b.return)) _a.call(_b); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| var children = visitAll$1(preparsedElement.nonBindable ? NON_BINDABLE_VISITOR$1 : this, element.children); |
| var parsedElement; |
| if (preparsedElement.type === PreparsedElementType.NG_CONTENT) { |
| // `<ng-content>` |
| if (element.children && |
| !element.children.every(function (node) { return isEmptyTextNode(node) || isCommentNode(node); })) { |
| this.reportError("<ng-content> element cannot have content.", element.sourceSpan); |
| } |
| var selector = preparsedElement.selectAttr; |
| var attrs = element.attrs.map(function (attr) { return _this.visitAttribute(attr); }); |
| parsedElement = new Content(selector, attrs, element.sourceSpan, element.i18n); |
| } |
| else if (isTemplateElement) { |
| // `<ng-template>` |
| var attrs = this.extractAttributes(element.name, parsedProperties, i18nAttrsMeta); |
| parsedElement = new Template(element.name, attributes, attrs.bound, boundEvents, [ /* no template attributes */], children, references, variables, element.sourceSpan, element.startSourceSpan, element.endSourceSpan, element.i18n); |
| } |
| else { |
| var attrs = this.extractAttributes(element.name, parsedProperties, i18nAttrsMeta); |
| parsedElement = new Element(element.name, attributes, attrs.bound, boundEvents, children, references, element.sourceSpan, element.startSourceSpan, element.endSourceSpan, element.i18n); |
| } |
| if (elementHasInlineTemplate) { |
| // If this node is an inline-template (e.g. has *ngFor) then we need to create a template |
| // node that contains this node. |
| // Moreover, if the node is an element, then we need to hoist its attributes to the template |
| // node for matching against content projection selectors. |
| var attrs = this.extractAttributes('ng-template', templateParsedProperties, i18nAttrsMeta); |
| var templateAttrs_1 = []; |
| attrs.literal.forEach(function (attr) { return templateAttrs_1.push(attr); }); |
| attrs.bound.forEach(function (attr) { return templateAttrs_1.push(attr); }); |
| var hoistedAttrs = parsedElement instanceof Element ? |
| { |
| attributes: parsedElement.attributes, |
| inputs: parsedElement.inputs, |
| outputs: parsedElement.outputs, |
| } : |
| { attributes: [], inputs: [], outputs: [] }; |
| // TODO(pk): test for this case |
| parsedElement = new Template(parsedElement.name, hoistedAttrs.attributes, hoistedAttrs.inputs, hoistedAttrs.outputs, templateAttrs_1, [parsedElement], [ /* no references */], templateVariables, element.sourceSpan, element.startSourceSpan, element.endSourceSpan, element.i18n); |
| } |
| return parsedElement; |
| }; |
| HtmlAstToIvyAst.prototype.visitAttribute = function (attribute) { |
| return new TextAttribute(attribute.name, attribute.value, attribute.sourceSpan, attribute.valueSpan, attribute.i18n); |
| }; |
| HtmlAstToIvyAst.prototype.visitText = function (text) { |
| return this._visitTextWithInterpolation(text.value, text.sourceSpan, text.i18n); |
| }; |
| HtmlAstToIvyAst.prototype.visitExpansion = function (expansion) { |
| var _this = this; |
| var meta = expansion.i18n; |
| // do not generate Icu in case it was created |
| // outside of i18n block in a template |
| if (!meta) { |
| return null; |
| } |
| var vars = {}; |
| var placeholders = {}; |
| // extract VARs from ICUs - we process them separately while |
| // assembling resulting message via goog.getMsg function, since |
| // we need to pass them to top-level goog.getMsg call |
| Object.keys(meta.placeholders).forEach(function (key) { |
| var value = meta.placeholders[key]; |
| if (key.startsWith(I18N_ICU_VAR_PREFIX)) { |
| var config = _this.bindingParser.interpolationConfig; |
| // ICU expression is a plain string, not wrapped into start |
| // and end tags, so we wrap it before passing to binding parser |
| var wrapped = "" + config.start + value + config.end; |
| vars[key] = _this._visitTextWithInterpolation(wrapped, expansion.sourceSpan); |
| } |
| else { |
| placeholders[key] = _this._visitTextWithInterpolation(value, expansion.sourceSpan); |
| } |
| }); |
| return new Icu(vars, placeholders, expansion.sourceSpan, meta); |
| }; |
| HtmlAstToIvyAst.prototype.visitExpansionCase = function (expansionCase) { return null; }; |
| HtmlAstToIvyAst.prototype.visitComment = function (comment) { return null; }; |
| // convert view engine `ParsedProperty` to a format suitable for IVY |
| HtmlAstToIvyAst.prototype.extractAttributes = function (elementName, properties, i18nPropsMeta) { |
| var _this = this; |
| var bound = []; |
| var literal = []; |
| properties.forEach(function (prop) { |
| var i18n = i18nPropsMeta[prop.name]; |
| if (prop.isLiteral) { |
| literal.push(new TextAttribute(prop.name, prop.expression.source || '', prop.sourceSpan, undefined, i18n)); |
| } |
| else { |
| // Note that validation is skipped and property mapping is disabled |
| // due to the fact that we need to make sure a given prop is not an |
| // input of a directive and directive matching happens at runtime. |
| var bep = _this.bindingParser.createBoundElementProperty(elementName, prop, /* skipValidation */ true, /* mapPropertyName */ false); |
| bound.push(BoundAttribute.fromBoundElementProperty(bep, i18n)); |
| } |
| }); |
| return { bound: bound, literal: literal }; |
| }; |
| HtmlAstToIvyAst.prototype.parseAttribute = function (isTemplateElement, attribute, matchableAttributes, parsedProperties, boundEvents, variables, references) { |
| var name = normalizeAttributeName(attribute.name); |
| var value = attribute.value; |
| var srcSpan = attribute.sourceSpan; |
| var bindParts = name.match(BIND_NAME_REGEXP$1); |
| var hasBinding = false; |
| if (bindParts) { |
| hasBinding = true; |
| if (bindParts[KW_BIND_IDX$1] != null) { |
| this.bindingParser.parsePropertyBinding(bindParts[IDENT_KW_IDX$1], value, false, srcSpan, matchableAttributes, parsedProperties); |
| } |
| else if (bindParts[KW_LET_IDX$1]) { |
| if (isTemplateElement) { |
| var identifier = bindParts[IDENT_KW_IDX$1]; |
| this.parseVariable(identifier, value, srcSpan, variables); |
| } |
| else { |
| this.reportError("\"let-\" is only supported on ng-template elements.", srcSpan); |
| } |
| } |
| else if (bindParts[KW_REF_IDX$1]) { |
| var identifier = bindParts[IDENT_KW_IDX$1]; |
| this.parseReference(identifier, value, srcSpan, references); |
| } |
| else if (bindParts[KW_ON_IDX$1]) { |
| var events = []; |
| this.bindingParser.parseEvent(bindParts[IDENT_KW_IDX$1], value, srcSpan, attribute.valueSpan || srcSpan, matchableAttributes, events); |
| addEvents(events, boundEvents); |
| } |
| else if (bindParts[KW_BINDON_IDX$1]) { |
| this.bindingParser.parsePropertyBinding(bindParts[IDENT_KW_IDX$1], value, false, srcSpan, matchableAttributes, parsedProperties); |
| this.parseAssignmentEvent(bindParts[IDENT_KW_IDX$1], value, srcSpan, attribute.valueSpan, matchableAttributes, boundEvents); |
| } |
| else if (bindParts[KW_AT_IDX$1]) { |
| this.bindingParser.parseLiteralAttr(name, value, srcSpan, matchableAttributes, parsedProperties); |
| } |
| else if (bindParts[IDENT_BANANA_BOX_IDX$1]) { |
| this.bindingParser.parsePropertyBinding(bindParts[IDENT_BANANA_BOX_IDX$1], value, false, srcSpan, matchableAttributes, parsedProperties); |
| this.parseAssignmentEvent(bindParts[IDENT_BANANA_BOX_IDX$1], value, srcSpan, attribute.valueSpan, matchableAttributes, boundEvents); |
| } |
| else if (bindParts[IDENT_PROPERTY_IDX$1]) { |
| this.bindingParser.parsePropertyBinding(bindParts[IDENT_PROPERTY_IDX$1], value, false, srcSpan, matchableAttributes, parsedProperties); |
| } |
| else if (bindParts[IDENT_EVENT_IDX$1]) { |
| var events = []; |
| this.bindingParser.parseEvent(bindParts[IDENT_EVENT_IDX$1], value, srcSpan, attribute.valueSpan || srcSpan, matchableAttributes, events); |
| addEvents(events, boundEvents); |
| } |
| } |
| else { |
| hasBinding = this.bindingParser.parsePropertyInterpolation(name, value, srcSpan, matchableAttributes, parsedProperties); |
| } |
| return hasBinding; |
| }; |
| HtmlAstToIvyAst.prototype._visitTextWithInterpolation = function (value, sourceSpan, i18n) { |
| var valueNoNgsp = replaceNgsp(value); |
| var expr = this.bindingParser.parseInterpolation(valueNoNgsp, sourceSpan); |
| return expr ? new BoundText(expr, sourceSpan, i18n) : new Text(valueNoNgsp, sourceSpan); |
| }; |
| HtmlAstToIvyAst.prototype.parseVariable = function (identifier, value, sourceSpan, variables) { |
| if (identifier.indexOf('-') > -1) { |
| this.reportError("\"-\" is not allowed in variable names", sourceSpan); |
| } |
| variables.push(new Variable(identifier, value, sourceSpan)); |
| }; |
| HtmlAstToIvyAst.prototype.parseReference = function (identifier, value, sourceSpan, references) { |
| if (identifier.indexOf('-') > -1) { |
| this.reportError("\"-\" is not allowed in reference names", sourceSpan); |
| } |
| references.push(new Reference(identifier, value, sourceSpan)); |
| }; |
| HtmlAstToIvyAst.prototype.parseAssignmentEvent = function (name, expression, sourceSpan, valueSpan, targetMatchableAttrs, boundEvents) { |
| var events = []; |
| this.bindingParser.parseEvent(name + "Change", expression + "=$event", sourceSpan, valueSpan || sourceSpan, targetMatchableAttrs, events); |
| addEvents(events, boundEvents); |
| }; |
| HtmlAstToIvyAst.prototype.reportError = function (message, sourceSpan, level) { |
| if (level === void 0) { level = exports.ParseErrorLevel.ERROR; } |
| this.errors.push(new ParseError(sourceSpan, message, level)); |
| }; |
| return HtmlAstToIvyAst; |
| }()); |
| var NonBindableVisitor$1 = /** @class */ (function () { |
| function NonBindableVisitor() { |
| } |
| NonBindableVisitor.prototype.visitElement = function (ast) { |
| var preparsedElement = preparseElement(ast); |
| if (preparsedElement.type === PreparsedElementType.SCRIPT || |
| preparsedElement.type === PreparsedElementType.STYLE || |
| preparsedElement.type === PreparsedElementType.STYLESHEET) { |
| // Skipping <script> for security reasons |
| // Skipping <style> and stylesheets as we already processed them |
| // in the StyleCompiler |
| return null; |
| } |
| var children = visitAll$1(this, ast.children, null); |
| return new Element(ast.name, visitAll$1(this, ast.attrs), |
| /* inputs */ [], /* outputs */ [], children, /* references */ [], ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan); |
| }; |
| NonBindableVisitor.prototype.visitComment = function (comment) { return null; }; |
| NonBindableVisitor.prototype.visitAttribute = function (attribute) { |
| return new TextAttribute(attribute.name, attribute.value, attribute.sourceSpan, undefined, attribute.i18n); |
| }; |
| NonBindableVisitor.prototype.visitText = function (text) { return new Text(text.value, text.sourceSpan); }; |
| NonBindableVisitor.prototype.visitExpansion = function (expansion) { return null; }; |
| NonBindableVisitor.prototype.visitExpansionCase = function (expansionCase) { return null; }; |
| return NonBindableVisitor; |
| }()); |
| var NON_BINDABLE_VISITOR$1 = new NonBindableVisitor$1(); |
| function normalizeAttributeName(attrName) { |
| return /^data-/i.test(attrName) ? attrName.substring(5) : attrName; |
| } |
| function addEvents(events, boundEvents) { |
| boundEvents.push.apply(boundEvents, __spread(events.map(function (e) { return BoundEvent.fromParsedEvent(e); }))); |
| } |
| function isEmptyTextNode(node) { |
| return node instanceof Text$3 && node.value.trim().length == 0; |
| } |
| function isCommentNode(node) { |
| return node instanceof Comment; |
| } |
| function textContents(node) { |
| if (node.children.length !== 1 || !(node.children[0] instanceof Text$3)) { |
| return null; |
| } |
| else { |
| return node.children[0].value; |
| } |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var TagType; |
| (function (TagType) { |
| TagType[TagType["ELEMENT"] = 0] = "ELEMENT"; |
| TagType[TagType["TEMPLATE"] = 1] = "TEMPLATE"; |
| TagType[TagType["PROJECTION"] = 2] = "PROJECTION"; |
| })(TagType || (TagType = {})); |
| /** |
| * Generates an object that is used as a shared state between parent and all child contexts. |
| */ |
| function setupRegistry() { |
| return { getUniqueId: getSeqNumberGenerator(), icus: new Map() }; |
| } |
| /** |
| * I18nContext is a helper class which keeps track of all i18n-related aspects |
| * (accumulates placeholders, bindings, etc) between i18nStart and i18nEnd instructions. |
| * |
| * When we enter a nested template, the top-level context is being passed down |
| * to the nested component, which uses this context to generate a child instance |
| * of I18nContext class (to handle nested template) and at the end, reconciles it back |
| * with the parent context. |
| * |
| * @param index Instruction index of i18nStart, which initiates this context |
| * @param ref Reference to a translation const that represents the content if thus context |
| * @param level Nestng level defined for child contexts |
| * @param templateIndex Instruction index of a template which this context belongs to |
| * @param meta Meta information (id, meaning, description, etc) associated with this context |
| */ |
| var I18nContext = /** @class */ (function () { |
| function I18nContext(index, ref, level, templateIndex, meta, registry) { |
| if (level === void 0) { level = 0; } |
| if (templateIndex === void 0) { templateIndex = null; } |
| this.index = index; |
| this.ref = ref; |
| this.level = level; |
| this.templateIndex = templateIndex; |
| this.meta = meta; |
| this.registry = registry; |
| this.bindings = new Set(); |
| this.placeholders = new Map(); |
| this.isEmitted = false; |
| this._unresolvedCtxCount = 0; |
| this._registry = registry || setupRegistry(); |
| this.id = this._registry.getUniqueId(); |
| } |
| I18nContext.prototype.appendTag = function (type, node, index, closed) { |
| if (node.isVoid && closed) { |
| return; // ignore "close" for void tags |
| } |
| var ph = node.isVoid || !closed ? node.startName : node.closeName; |
| var content = { type: type, index: index, ctx: this.id, isVoid: node.isVoid, closed: closed }; |
| updatePlaceholderMap(this.placeholders, ph, content); |
| }; |
| Object.defineProperty(I18nContext.prototype, "icus", { |
| get: function () { return this._registry.icus; }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(I18nContext.prototype, "isRoot", { |
| get: function () { return this.level === 0; }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(I18nContext.prototype, "isResolved", { |
| get: function () { return this._unresolvedCtxCount === 0; }, |
| enumerable: true, |
| configurable: true |
| }); |
| I18nContext.prototype.getSerializedPlaceholders = function () { |
| var result = new Map(); |
| this.placeholders.forEach(function (values, key) { return result.set(key, values.map(serializePlaceholderValue)); }); |
| return result; |
| }; |
| // public API to accumulate i18n-related content |
| I18nContext.prototype.appendBinding = function (binding) { this.bindings.add(binding); }; |
| I18nContext.prototype.appendIcu = function (name, ref) { |
| updatePlaceholderMap(this._registry.icus, name, ref); |
| }; |
| I18nContext.prototype.appendBoundText = function (node) { |
| var _this = this; |
| var phs = assembleBoundTextPlaceholders(node, this.bindings.size, this.id); |
| phs.forEach(function (values, key) { return updatePlaceholderMap.apply(void 0, __spread([_this.placeholders, key], values)); }); |
| }; |
| I18nContext.prototype.appendTemplate = function (node, index) { |
| // add open and close tags at the same time, |
| // since we process nested templates separately |
| this.appendTag(TagType.TEMPLATE, node, index, false); |
| this.appendTag(TagType.TEMPLATE, node, index, true); |
| this._unresolvedCtxCount++; |
| }; |
| I18nContext.prototype.appendElement = function (node, index, closed) { |
| this.appendTag(TagType.ELEMENT, node, index, closed); |
| }; |
| I18nContext.prototype.appendProjection = function (node, index) { |
| // add open and close tags at the same time, |
| // since we process projected content separately |
| this.appendTag(TagType.PROJECTION, node, index, false); |
| this.appendTag(TagType.PROJECTION, node, index, true); |
| }; |
| /** |
| * Generates an instance of a child context based on the root one, |
| * when we enter a nested template within I18n section. |
| * |
| * @param index Instruction index of corresponding i18nStart, which initiates this context |
| * @param templateIndex Instruction index of a template which this context belongs to |
| * @param meta Meta information (id, meaning, description, etc) associated with this context |
| * |
| * @returns I18nContext instance |
| */ |
| I18nContext.prototype.forkChildContext = function (index, templateIndex, meta) { |
| return new I18nContext(index, this.ref, this.level + 1, templateIndex, meta, this._registry); |
| }; |
| /** |
| * Reconciles child context into parent one once the end of the i18n block is reached (i18nEnd). |
| * |
| * @param context Child I18nContext instance to be reconciled with parent context. |
| */ |
| I18nContext.prototype.reconcileChildContext = function (context) { |
| var _this = this; |
| // set the right context id for open and close |
| // template tags, so we can use it as sub-block ids |
| ['start', 'close'].forEach(function (op) { |
| var key = context.meta[op + "Name"]; |
| var phs = _this.placeholders.get(key) || []; |
| var tag = phs.find(findTemplateFn(_this.id, context.templateIndex)); |
| if (tag) { |
| tag.ctx = context.id; |
| } |
| }); |
| // reconcile placeholders |
| var childPhs = context.placeholders; |
| childPhs.forEach(function (values, key) { |
| var phs = _this.placeholders.get(key); |
| if (!phs) { |
| _this.placeholders.set(key, values); |
| return; |
| } |
| // try to find matching template... |
| var tmplIdx = findIndex(phs, findTemplateFn(context.id, context.templateIndex)); |
| if (tmplIdx >= 0) { |
| // ... if found - replace it with nested template content |
| var isCloseTag = key.startsWith('CLOSE'); |
| var isTemplateTag = key.endsWith('NG-TEMPLATE'); |
| if (isTemplateTag) { |
| // current template's content is placed before or after |
| // parent template tag, depending on the open/close atrribute |
| phs.splice.apply(phs, __spread([tmplIdx + (isCloseTag ? 0 : 1), 0], values)); |
| } |
| else { |
| var idx = isCloseTag ? values.length - 1 : 0; |
| values[idx].tmpl = phs[tmplIdx]; |
| phs.splice.apply(phs, __spread([tmplIdx, 1], values)); |
| } |
| } |
| else { |
| // ... otherwise just append content to placeholder value |
| phs.push.apply(phs, __spread(values)); |
| } |
| _this.placeholders.set(key, phs); |
| }); |
| this._unresolvedCtxCount--; |
| }; |
| return I18nContext; |
| }()); |
| // |
| // Helper methods |
| // |
| function wrap(symbol, index, contextId, closed) { |
| var state = closed ? '/' : ''; |
| return wrapI18nPlaceholder("" + state + symbol + index, contextId); |
| } |
| function wrapTag(symbol, _a, closed) { |
| var index = _a.index, ctx = _a.ctx, isVoid = _a.isVoid; |
| return isVoid ? wrap(symbol, index, ctx) + wrap(symbol, index, ctx, true) : |
| wrap(symbol, index, ctx, closed); |
| } |
| function findTemplateFn(ctx, templateIndex) { |
| return function (token) { return typeof token === 'object' && token.type === TagType.TEMPLATE && |
| token.index === templateIndex && token.ctx === ctx; }; |
| } |
| function serializePlaceholderValue(value) { |
| var element = function (data, closed) { return wrapTag('#', data, closed); }; |
| var template = function (data, closed) { return wrapTag('*', data, closed); }; |
| var projection = function (data, closed) { return wrapTag('!', data, closed); }; |
| switch (value.type) { |
| case TagType.ELEMENT: |
| // close element tag |
| if (value.closed) { |
| return element(value, true) + (value.tmpl ? template(value.tmpl, true) : ''); |
| } |
| // open element tag that also initiates a template |
| if (value.tmpl) { |
| return template(value.tmpl) + element(value) + |
| (value.isVoid ? template(value.tmpl, true) : ''); |
| } |
| return element(value); |
| case TagType.TEMPLATE: |
| return template(value, value.closed); |
| case TagType.PROJECTION: |
| return projection(value, value.closed); |
| default: |
| return value; |
| } |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var TAG_TO_PLACEHOLDER_NAMES = { |
| 'A': 'LINK', |
| 'B': 'BOLD_TEXT', |
| 'BR': 'LINE_BREAK', |
| 'EM': 'EMPHASISED_TEXT', |
| 'H1': 'HEADING_LEVEL1', |
| 'H2': 'HEADING_LEVEL2', |
| 'H3': 'HEADING_LEVEL3', |
| 'H4': 'HEADING_LEVEL4', |
| 'H5': 'HEADING_LEVEL5', |
| 'H6': 'HEADING_LEVEL6', |
| 'HR': 'HORIZONTAL_RULE', |
| 'I': 'ITALIC_TEXT', |
| 'LI': 'LIST_ITEM', |
| 'LINK': 'MEDIA_LINK', |
| 'OL': 'ORDERED_LIST', |
| 'P': 'PARAGRAPH', |
| 'Q': 'QUOTATION', |
| 'S': 'STRIKETHROUGH_TEXT', |
| 'SMALL': 'SMALL_TEXT', |
| 'SUB': 'SUBSTRIPT', |
| 'SUP': 'SUPERSCRIPT', |
| 'TBODY': 'TABLE_BODY', |
| 'TD': 'TABLE_CELL', |
| 'TFOOT': 'TABLE_FOOTER', |
| 'TH': 'TABLE_HEADER_CELL', |
| 'THEAD': 'TABLE_HEADER', |
| 'TR': 'TABLE_ROW', |
| 'TT': 'MONOSPACED_TEXT', |
| 'U': 'UNDERLINED_TEXT', |
| 'UL': 'UNORDERED_LIST', |
| }; |
| /** |
| * Creates unique names for placeholder with different content. |
| * |
| * Returns the same placeholder name when the content is identical. |
| */ |
| var PlaceholderRegistry = /** @class */ (function () { |
| function PlaceholderRegistry() { |
| // Count the occurrence of the base name top generate a unique name |
| this._placeHolderNameCounts = {}; |
| // Maps signature to placeholder names |
| this._signatureToName = {}; |
| } |
| PlaceholderRegistry.prototype.getStartTagPlaceholderName = function (tag, attrs, isVoid) { |
| var signature = this._hashTag(tag, attrs, isVoid); |
| if (this._signatureToName[signature]) { |
| return this._signatureToName[signature]; |
| } |
| var upperTag = tag.toUpperCase(); |
| var baseName = TAG_TO_PLACEHOLDER_NAMES[upperTag] || "TAG_" + upperTag; |
| var name = this._generateUniqueName(isVoid ? baseName : "START_" + baseName); |
| this._signatureToName[signature] = name; |
| return name; |
| }; |
| PlaceholderRegistry.prototype.getCloseTagPlaceholderName = function (tag) { |
| var signature = this._hashClosingTag(tag); |
| if (this._signatureToName[signature]) { |
| return this._signatureToName[signature]; |
| } |
| var upperTag = tag.toUpperCase(); |
| var baseName = TAG_TO_PLACEHOLDER_NAMES[upperTag] || "TAG_" + upperTag; |
| var name = this._generateUniqueName("CLOSE_" + baseName); |
| this._signatureToName[signature] = name; |
| return name; |
| }; |
| PlaceholderRegistry.prototype.getPlaceholderName = function (name, content) { |
| var upperName = name.toUpperCase(); |
| var signature = "PH: " + upperName + "=" + content; |
| if (this._signatureToName[signature]) { |
| return this._signatureToName[signature]; |
| } |
| var uniqueName = this._generateUniqueName(upperName); |
| this._signatureToName[signature] = uniqueName; |
| return uniqueName; |
| }; |
| PlaceholderRegistry.prototype.getUniquePlaceholder = function (name) { |
| return this._generateUniqueName(name.toUpperCase()); |
| }; |
| // Generate a hash for a tag - does not take attribute order into account |
| PlaceholderRegistry.prototype._hashTag = function (tag, attrs, isVoid) { |
| var start = "<" + tag; |
| var strAttrs = Object.keys(attrs).sort().map(function (name) { return " " + name + "=" + attrs[name]; }).join(''); |
| var end = isVoid ? '/>' : "></" + tag + ">"; |
| return start + strAttrs + end; |
| }; |
| PlaceholderRegistry.prototype._hashClosingTag = function (tag) { return this._hashTag("/" + tag, {}, false); }; |
| PlaceholderRegistry.prototype._generateUniqueName = function (base) { |
| var seen = this._placeHolderNameCounts.hasOwnProperty(base); |
| if (!seen) { |
| this._placeHolderNameCounts[base] = 1; |
| return base; |
| } |
| var id = this._placeHolderNameCounts[base]; |
| this._placeHolderNameCounts[base] = id + 1; |
| return base + "_" + id; |
| }; |
| return PlaceholderRegistry; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var _expParser = new Parser$1(new Lexer()); |
| /** |
| * Returns a function converting html nodes to an i18n Message given an interpolationConfig |
| */ |
| function createI18nMessageFactory(interpolationConfig) { |
| var visitor = new _I18nVisitor(_expParser, interpolationConfig); |
| return function (nodes, meaning, description, id, visitNodeFn) { |
| return visitor.toI18nMessage(nodes, meaning, description, id, visitNodeFn); |
| }; |
| } |
| var _I18nVisitor = /** @class */ (function () { |
| function _I18nVisitor(_expressionParser, _interpolationConfig) { |
| this._expressionParser = _expressionParser; |
| this._interpolationConfig = _interpolationConfig; |
| } |
| _I18nVisitor.prototype.toI18nMessage = function (nodes, meaning, description, id, visitNodeFn) { |
| this._isIcu = nodes.length == 1 && nodes[0] instanceof Expansion; |
| this._icuDepth = 0; |
| this._placeholderRegistry = new PlaceholderRegistry(); |
| this._placeholderToContent = {}; |
| this._placeholderToMessage = {}; |
| this._visitNodeFn = visitNodeFn; |
| var i18nodes = visitAll$1(this, nodes, {}); |
| return new Message(i18nodes, this._placeholderToContent, this._placeholderToMessage, meaning, description, id); |
| }; |
| _I18nVisitor.prototype._visitNode = function (html, i18n) { |
| if (this._visitNodeFn) { |
| this._visitNodeFn(html, i18n); |
| } |
| return i18n; |
| }; |
| _I18nVisitor.prototype.visitElement = function (el, context) { |
| var children = visitAll$1(this, el.children); |
| var attrs = {}; |
| el.attrs.forEach(function (attr) { |
| // Do not visit the attributes, translatable ones are top-level ASTs |
| attrs[attr.name] = attr.value; |
| }); |
| var isVoid = getHtmlTagDefinition(el.name).isVoid; |
| var startPhName = this._placeholderRegistry.getStartTagPlaceholderName(el.name, attrs, isVoid); |
| this._placeholderToContent[startPhName] = el.sourceSpan.toString(); |
| var closePhName = ''; |
| if (!isVoid) { |
| closePhName = this._placeholderRegistry.getCloseTagPlaceholderName(el.name); |
| this._placeholderToContent[closePhName] = "</" + el.name + ">"; |
| } |
| var node = new TagPlaceholder(el.name, attrs, startPhName, closePhName, children, isVoid, el.sourceSpan); |
| return this._visitNode(el, node); |
| }; |
| _I18nVisitor.prototype.visitAttribute = function (attribute, context) { |
| var node = this._visitTextWithInterpolation(attribute.value, attribute.sourceSpan); |
| return this._visitNode(attribute, node); |
| }; |
| _I18nVisitor.prototype.visitText = function (text, context) { |
| var node = this._visitTextWithInterpolation(text.value, text.sourceSpan); |
| return this._visitNode(text, node); |
| }; |
| _I18nVisitor.prototype.visitComment = function (comment, context) { return null; }; |
| _I18nVisitor.prototype.visitExpansion = function (icu, context) { |
| var _this = this; |
| this._icuDepth++; |
| var i18nIcuCases = {}; |
| var i18nIcu = new Icu$1(icu.switchValue, icu.type, i18nIcuCases, icu.sourceSpan); |
| icu.cases.forEach(function (caze) { |
| i18nIcuCases[caze.value] = new Container(caze.expression.map(function (node) { return node.visit(_this, {}); }), caze.expSourceSpan); |
| }); |
| this._icuDepth--; |
| if (this._isIcu || this._icuDepth > 0) { |
| // Returns an ICU node when: |
| // - the message (vs a part of the message) is an ICU message, or |
| // - the ICU message is nested. |
| var expPh = this._placeholderRegistry.getUniquePlaceholder("VAR_" + icu.type); |
| i18nIcu.expressionPlaceholder = expPh; |
| this._placeholderToContent[expPh] = icu.switchValue; |
| return this._visitNode(icu, i18nIcu); |
| } |
| // Else returns a placeholder |
| // ICU placeholders should not be replaced with their original content but with the their |
| // translations. We need to create a new visitor (they are not re-entrant) to compute the |
| // message id. |
| // TODO(vicb): add a html.Node -> i18n.Message cache to avoid having to re-create the msg |
| var phName = this._placeholderRegistry.getPlaceholderName('ICU', icu.sourceSpan.toString()); |
| var visitor = new _I18nVisitor(this._expressionParser, this._interpolationConfig); |
| this._placeholderToMessage[phName] = visitor.toI18nMessage([icu], '', '', ''); |
| var node = new IcuPlaceholder(i18nIcu, phName, icu.sourceSpan); |
| return this._visitNode(icu, node); |
| }; |
| _I18nVisitor.prototype.visitExpansionCase = function (icuCase, context) { |
| throw new Error('Unreachable code'); |
| }; |
| _I18nVisitor.prototype._visitTextWithInterpolation = function (text, sourceSpan) { |
| var splitInterpolation = this._expressionParser.splitInterpolation(text, sourceSpan.start.toString(), this._interpolationConfig); |
| if (!splitInterpolation) { |
| // No expression, return a single text |
| return new Text$1(text, sourceSpan); |
| } |
| // Return a group of text + expressions |
| var nodes = []; |
| var container = new Container(nodes, sourceSpan); |
| var _a = this._interpolationConfig, sDelimiter = _a.start, eDelimiter = _a.end; |
| for (var i = 0; i < splitInterpolation.strings.length - 1; i++) { |
| var expression = splitInterpolation.expressions[i]; |
| var baseName = _extractPlaceholderName(expression) || 'INTERPOLATION'; |
| var phName = this._placeholderRegistry.getPlaceholderName(baseName, expression); |
| if (splitInterpolation.strings[i].length) { |
| // No need to add empty strings |
| nodes.push(new Text$1(splitInterpolation.strings[i], sourceSpan)); |
| } |
| nodes.push(new Placeholder(expression, phName, sourceSpan)); |
| this._placeholderToContent[phName] = sDelimiter + expression + eDelimiter; |
| } |
| // The last index contains no expression |
| var lastStringIdx = splitInterpolation.strings.length - 1; |
| if (splitInterpolation.strings[lastStringIdx].length) { |
| nodes.push(new Text$1(splitInterpolation.strings[lastStringIdx], sourceSpan)); |
| } |
| return container; |
| }; |
| return _I18nVisitor; |
| }()); |
| var _CUSTOM_PH_EXP = /\/\/[\s\S]*i18n[\s\S]*\([\s\S]*ph[\s\S]*=[\s\S]*("|')([\s\S]*?)\1[\s\S]*\)/g; |
| function _extractPlaceholderName(input) { |
| return input.split(_CUSTOM_PH_EXP)[2]; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| function setI18nRefs(html, i18n) { |
| html.i18n = i18n; |
| } |
| /** |
| * This visitor walks over HTML parse tree and converts information stored in |
| * i18n-related attributes ("i18n" and "i18n-*") into i18n meta object that is |
| * stored with other element's and attribute's information. |
| */ |
| var I18nMetaVisitor = /** @class */ (function () { |
| function I18nMetaVisitor(interpolationConfig, keepI18nAttrs) { |
| if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; } |
| if (keepI18nAttrs === void 0) { keepI18nAttrs = false; } |
| this.interpolationConfig = interpolationConfig; |
| this.keepI18nAttrs = keepI18nAttrs; |
| // i18n message generation factory |
| this._createI18nMessage = createI18nMessageFactory(interpolationConfig); |
| } |
| I18nMetaVisitor.prototype._generateI18nMessage = function (nodes, meta, visitNodeFn) { |
| if (meta === void 0) { meta = ''; } |
| var parsed = typeof meta === 'string' ? parseI18nMeta(meta) : metaFromI18nMessage(meta); |
| var message = this._createI18nMessage(nodes, parsed.meaning || '', parsed.description || '', parsed.id || '', visitNodeFn); |
| if (!message.id) { |
| // generate (or restore) message id if not specified in template |
| message.id = typeof meta !== 'string' && meta.id || decimalDigest(message); |
| } |
| return message; |
| }; |
| I18nMetaVisitor.prototype.visitElement = function (element, context) { |
| var e_1, _a, e_2, _b; |
| if (hasI18nAttrs(element)) { |
| var attrs = []; |
| var attrsMeta = {}; |
| try { |
| for (var _c = __values(element.attrs), _d = _c.next(); !_d.done; _d = _c.next()) { |
| var attr = _d.value; |
| if (attr.name === I18N_ATTR) { |
| // root 'i18n' node attribute |
| var i18n_1 = element.i18n || attr.value; |
| var message = this._generateI18nMessage(element.children, i18n_1, setI18nRefs); |
| // do not assign empty i18n meta |
| if (message.nodes.length) { |
| element.i18n = message; |
| } |
| } |
| else if (attr.name.startsWith(I18N_ATTR_PREFIX)) { |
| // 'i18n-*' attributes |
| var key = attr.name.slice(I18N_ATTR_PREFIX.length); |
| attrsMeta[key] = attr.value; |
| } |
| else { |
| // non-i18n attributes |
| attrs.push(attr); |
| } |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (_d && !_d.done && (_a = _c.return)) _a.call(_c); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| // set i18n meta for attributes |
| if (Object.keys(attrsMeta).length) { |
| try { |
| for (var attrs_1 = __values(attrs), attrs_1_1 = attrs_1.next(); !attrs_1_1.done; attrs_1_1 = attrs_1.next()) { |
| var attr = attrs_1_1.value; |
| var meta = attrsMeta[attr.name]; |
| // do not create translation for empty attributes |
| if (meta !== undefined && attr.value) { |
| attr.i18n = this._generateI18nMessage([attr], attr.i18n || meta); |
| } |
| } |
| } |
| catch (e_2_1) { e_2 = { error: e_2_1 }; } |
| finally { |
| try { |
| if (attrs_1_1 && !attrs_1_1.done && (_b = attrs_1.return)) _b.call(attrs_1); |
| } |
| finally { if (e_2) throw e_2.error; } |
| } |
| } |
| if (!this.keepI18nAttrs) { |
| // update element's attributes, |
| // keeping only non-i18n related ones |
| element.attrs = attrs; |
| } |
| } |
| visitAll$1(this, element.children); |
| return element; |
| }; |
| I18nMetaVisitor.prototype.visitExpansion = function (expansion, context) { |
| var message; |
| var meta = expansion.i18n; |
| if (meta instanceof IcuPlaceholder) { |
| // set ICU placeholder name (e.g. "ICU_1"), |
| // generated while processing root element contents, |
| // so we can reference it when we output translation |
| var name_1 = meta.name; |
| message = this._generateI18nMessage([expansion], meta); |
| var icu = icuFromI18nMessage(message); |
| icu.name = name_1; |
| } |
| else { |
| // when ICU is a root level translation |
| message = this._generateI18nMessage([expansion], meta); |
| } |
| expansion.i18n = message; |
| return expansion; |
| }; |
| I18nMetaVisitor.prototype.visitText = function (text, context) { return text; }; |
| I18nMetaVisitor.prototype.visitAttribute = function (attribute, context) { return attribute; }; |
| I18nMetaVisitor.prototype.visitComment = function (comment, context) { return comment; }; |
| I18nMetaVisitor.prototype.visitExpansionCase = function (expansionCase, context) { return expansionCase; }; |
| return I18nMetaVisitor; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var formatPh = function (value) { return "{$" + formatI18nPlaceholderName(value) + "}"; }; |
| /** |
| * This visitor walks over i18n tree and generates its string representation, |
| * including ICUs and placeholders in {$PLACEHOLDER} format. |
| */ |
| var SerializerVisitor = /** @class */ (function () { |
| function SerializerVisitor() { |
| } |
| SerializerVisitor.prototype.visitText = function (text, context) { return text.value; }; |
| SerializerVisitor.prototype.visitContainer = function (container, context) { |
| var _this = this; |
| return container.children.map(function (child) { return child.visit(_this); }).join(''); |
| }; |
| SerializerVisitor.prototype.visitIcu = function (icu, context) { |
| var _this = this; |
| var strCases = Object.keys(icu.cases).map(function (k) { return k + " {" + icu.cases[k].visit(_this) + "}"; }); |
| return "{" + icu.expressionPlaceholder + ", " + icu.type + ", " + strCases.join(' ') + "}"; |
| }; |
| SerializerVisitor.prototype.visitTagPlaceholder = function (ph, context) { |
| var _this = this; |
| return ph.isVoid ? |
| formatPh(ph.startName) : |
| "" + formatPh(ph.startName) + ph.children.map(function (child) { return child.visit(_this); }).join('') + formatPh(ph.closeName); |
| }; |
| SerializerVisitor.prototype.visitPlaceholder = function (ph, context) { return formatPh(ph.name); }; |
| SerializerVisitor.prototype.visitIcuPlaceholder = function (ph, context) { return formatPh(ph.name); }; |
| return SerializerVisitor; |
| }()); |
| var serializerVisitor$1 = new SerializerVisitor(); |
| function getSerializedI18nContent(message) { |
| return message.nodes.map(function (node) { return node.visit(serializerVisitor$1, null); }).join(''); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| // Selector attribute name of `<ng-content>` |
| var NG_CONTENT_SELECT_ATTR$1 = 'select'; |
| // Attribute name of `ngProjectAs`. |
| var NG_PROJECT_AS_ATTR_NAME = 'ngProjectAs'; |
| // List of supported global targets for event listeners |
| var GLOBAL_TARGET_RESOLVERS = new Map([['window', Identifiers$1.resolveWindow], ['document', Identifiers$1.resolveDocument], ['body', Identifiers$1.resolveBody]]); |
| var LEADING_TRIVIA_CHARS = [' ', '\n', '\r', '\t']; |
| // if (rf & flags) { .. } |
| function renderFlagCheckIfStmt(flags, statements) { |
| return ifStmt(variable(RENDER_FLAGS).bitwiseAnd(literal(flags), null, false), statements); |
| } |
| function prepareEventListenerParameters(eventAst, handlerName, scope) { |
| if (handlerName === void 0) { handlerName = null; } |
| if (scope === void 0) { scope = null; } |
| var type = eventAst.type, name = eventAst.name, target = eventAst.target, phase = eventAst.phase, handler = eventAst.handler; |
| if (target && !GLOBAL_TARGET_RESOLVERS.has(target)) { |
| throw new Error("Unexpected global target '" + target + "' defined for '" + name + "' event.\n Supported list of global targets: " + Array.from(GLOBAL_TARGET_RESOLVERS.keys()) + "."); |
| } |
| var implicitReceiverExpr = (scope === null || scope.bindingLevel === 0) ? |
| variable(CONTEXT_NAME) : |
| scope.getOrCreateSharedContextVar(0); |
| var bindingExpr = convertActionBinding(scope, implicitReceiverExpr, handler, 'b', function () { return error('Unexpected interpolation'); }, eventAst.handlerSpan); |
| var statements = []; |
| if (scope) { |
| statements.push.apply(statements, __spread(scope.restoreViewStatement())); |
| statements.push.apply(statements, __spread(scope.variableDeclarations())); |
| } |
| statements.push.apply(statements, __spread(bindingExpr.render3Stmts)); |
| var eventName = type === 1 /* Animation */ ? prepareSyntheticListenerName(name, phase) : name; |
| var fnName = handlerName && sanitizeIdentifier(handlerName); |
| var fnArgs = [new FnParam('$event', DYNAMIC_TYPE)]; |
| var handlerFn = fn(fnArgs, statements, INFERRED_TYPE, null, fnName); |
| var params = [literal(eventName), handlerFn]; |
| if (target) { |
| params.push(literal(false), // `useCapture` flag, defaults to `false` |
| importExpr(GLOBAL_TARGET_RESOLVERS.get(target))); |
| } |
| return params; |
| } |
| var TemplateDefinitionBuilder = /** @class */ (function () { |
| function TemplateDefinitionBuilder(constantPool, parentBindingScope, level, contextName, i18nContext, templateIndex, templateName, directiveMatcher, directives, pipeTypeByName, pipes, _namespace, relativeContextFilePath, i18nUseExternalIds) { |
| var _this = this; |
| if (level === void 0) { level = 0; } |
| this.constantPool = constantPool; |
| this.level = level; |
| this.contextName = contextName; |
| this.i18nContext = i18nContext; |
| this.templateIndex = templateIndex; |
| this.templateName = templateName; |
| this.directiveMatcher = directiveMatcher; |
| this.directives = directives; |
| this.pipeTypeByName = pipeTypeByName; |
| this.pipes = pipes; |
| this._namespace = _namespace; |
| this.relativeContextFilePath = relativeContextFilePath; |
| this.i18nUseExternalIds = i18nUseExternalIds; |
| this._dataIndex = 0; |
| this._bindingContext = 0; |
| this._prefixCode = []; |
| /** |
| * List of callbacks to generate creation mode instructions. We store them here as we process |
| * the template so bindings in listeners are resolved only once all nodes have been visited. |
| * This ensures all local refs and context variables are available for matching. |
| */ |
| this._creationCodeFns = []; |
| /** |
| * List of callbacks to generate update mode instructions. We store them here as we process |
| * the template so bindings are resolved only once all nodes have been visited. This ensures |
| * all local refs and context variables are available for matching. |
| */ |
| this._updateCodeFns = []; |
| /** |
| * Memorizes the last node index for which a select instruction has been generated. |
| * We're initializing this to -1 to ensure the `select(0)` instruction is generated before any |
| * relevant update instructions. |
| */ |
| this._lastNodeIndexWithFlush = -1; |
| /** Temporary variable declarations generated from visiting pipes, literals, etc. */ |
| this._tempVariables = []; |
| /** |
| * List of callbacks to build nested templates. Nested templates must not be visited until |
| * after the parent template has finished visiting all of its nodes. This ensures that all |
| * local ref bindings in nested templates are able to find local ref values if the refs |
| * are defined after the template declaration. |
| */ |
| this._nestedTemplateFns = []; |
| this._unsupported = unsupported; |
| // i18n context local to this template |
| this.i18n = null; |
| // Number of slots to reserve for pureFunctions |
| this._pureFunctionSlots = 0; |
| // Number of binding slots |
| this._bindingSlots = 0; |
| // Projection slots found in the template. Projection slots can distribute projected |
| // nodes based on a selector, or can just use the wildcard selector to match |
| // all nodes which aren't matching any selector. |
| this._ngContentReservedSlots = []; |
| // Number of non-default selectors found in all parent templates of this template. We need to |
| // track it to properly adjust projection slot index in the `projection` instruction. |
| this._ngContentSelectorsOffset = 0; |
| // Expression that should be used as implicit receiver when converting template |
| // expressions to output AST. |
| this._implicitReceiverExpr = null; |
| // These should be handled in the template or element directly. |
| this.visitReference = invalid$1; |
| this.visitVariable = invalid$1; |
| this.visitTextAttribute = invalid$1; |
| this.visitBoundAttribute = invalid$1; |
| this.visitBoundEvent = invalid$1; |
| this._bindingScope = parentBindingScope.nestedScope(level); |
| // Turn the relative context file path into an identifier by replacing non-alphanumeric |
| // characters with underscores. |
| this.fileBasedI18nSuffix = relativeContextFilePath.replace(/[^A-Za-z0-9]/g, '_') + '_'; |
| this._valueConverter = new ValueConverter(constantPool, function () { return _this.allocateDataSlot(); }, function (numSlots) { return _this.allocatePureFunctionSlots(numSlots); }, function (name, localName, slot, value) { |
| var pipeType = pipeTypeByName.get(name); |
| if (pipeType) { |
| _this.pipes.add(pipeType); |
| } |
| _this._bindingScope.set(_this.level, localName, value); |
| _this.creationInstruction(null, Identifiers$1.pipe, [literal(slot), literal(name)]); |
| }); |
| } |
| TemplateDefinitionBuilder.prototype.registerContextVariables = function (variable$1) { |
| var scopedName = this._bindingScope.freshReferenceName(); |
| var retrievalLevel = this.level; |
| var lhs = variable(variable$1.name + scopedName); |
| this._bindingScope.set(retrievalLevel, variable$1.name, lhs, 1 /* CONTEXT */, function (scope, relativeLevel) { |
| var rhs; |
| if (scope.bindingLevel === retrievalLevel) { |
| // e.g. ctx |
| rhs = variable(CONTEXT_NAME); |
| } |
| else { |
| var sharedCtxVar = scope.getSharedContextName(retrievalLevel); |
| // e.g. ctx_r0 OR x(2); |
| rhs = sharedCtxVar ? sharedCtxVar : generateNextContextExpr(relativeLevel); |
| } |
| // e.g. const $item$ = x(2).$implicit; |
| return [lhs.set(rhs.prop(variable$1.value || IMPLICIT_REFERENCE)).toConstDecl()]; |
| }); |
| }; |
| TemplateDefinitionBuilder.prototype.buildTemplateFunction = function (nodes, variables, ngContentSelectorsOffset, i18n) { |
| var _this = this; |
| if (ngContentSelectorsOffset === void 0) { ngContentSelectorsOffset = 0; } |
| this._ngContentSelectorsOffset = ngContentSelectorsOffset; |
| if (this._namespace !== Identifiers$1.namespaceHTML) { |
| this.creationInstruction(null, this._namespace); |
| } |
| // Create variable bindings |
| variables.forEach(function (v) { return _this.registerContextVariables(v); }); |
| // Initiate i18n context in case: |
| // - this template has parent i18n context |
| // - or the template has i18n meta associated with it, |
| // but it's not initiated by the Element (e.g. <ng-template i18n>) |
| var initI18nContext = this.i18nContext || (isI18nRootNode(i18n) && !isSingleI18nIcu(i18n) && |
| !(isSingleElementTemplate(nodes) && nodes[0].i18n === i18n)); |
| var selfClosingI18nInstruction = hasTextChildrenOnly(nodes); |
| if (initI18nContext) { |
| this.i18nStart(null, i18n, selfClosingI18nInstruction); |
| } |
| // This is the initial pass through the nodes of this template. In this pass, we |
| // queue all creation mode and update mode instructions for generation in the second |
| // pass. It's necessary to separate the passes to ensure local refs are defined before |
| // resolving bindings. We also count bindings in this pass as we walk bound expressions. |
| visitAll(this, nodes); |
| // Add total binding count to pure function count so pure function instructions are |
| // generated with the correct slot offset when update instructions are processed. |
| this._pureFunctionSlots += this._bindingSlots; |
| // Pipes are walked in the first pass (to enqueue `pipe()` creation instructions and |
| // `pipeBind` update instructions), so we have to update the slot offsets manually |
| // to account for bindings. |
| this._valueConverter.updatePipeSlotOffsets(this._bindingSlots); |
| // Nested templates must be processed before creation instructions so template() |
| // instructions can be generated with the correct internal const count. |
| this._nestedTemplateFns.forEach(function (buildTemplateFn) { return buildTemplateFn(); }); |
| // Output the `projectionDef` instruction when some `<ng-content>` tags are present. |
| // The `projectionDef` instruction is only emitted for the component template and |
| // is skipped for nested templates (<ng-template> tags). |
| if (this.level === 0 && this._ngContentReservedSlots.length) { |
| var parameters = []; |
| // By default the `projectionDef` instructions creates one slot for the wildcard |
| // selector if no parameters are passed. Therefore we only want to allocate a new |
| // array for the projection slots if the default projection slot is not sufficient. |
| if (this._ngContentReservedSlots.length > 1 || this._ngContentReservedSlots[0] !== '*') { |
| var r3ReservedSlots = this._ngContentReservedSlots.map(function (s) { return s !== '*' ? parseSelectorToR3Selector(s) : s; }); |
| parameters.push(this.constantPool.getConstLiteral(asLiteral(r3ReservedSlots), true)); |
| } |
| // Since we accumulate ngContent selectors while processing template elements, |
| // we *prepend* `projectionDef` to creation instructions block, to put it before |
| // any `projection` instructions |
| this.creationInstruction(null, Identifiers$1.projectionDef, parameters, /* prepend */ true); |
| } |
| if (initI18nContext) { |
| this.i18nEnd(null, selfClosingI18nInstruction); |
| } |
| // Generate all the creation mode instructions (e.g. resolve bindings in listeners) |
| var creationStatements = this._creationCodeFns.map(function (fn) { return fn(); }); |
| // Generate all the update mode instructions (e.g. resolve property or text bindings) |
| var updateStatements = this._updateCodeFns.map(function (fn) { return fn(); }); |
| // Variable declaration must occur after binding resolution so we can generate context |
| // instructions that build on each other. |
| // e.g. const b = nextContext().$implicit(); const b = nextContext(); |
| var creationVariables = this._bindingScope.viewSnapshotStatements(); |
| var updateVariables = this._bindingScope.variableDeclarations().concat(this._tempVariables); |
| var creationBlock = creationStatements.length > 0 ? |
| [renderFlagCheckIfStmt(1 /* Create */, creationVariables.concat(creationStatements))] : |
| []; |
| var updateBlock = updateStatements.length > 0 ? |
| [renderFlagCheckIfStmt(2 /* Update */, updateVariables.concat(updateStatements))] : |
| []; |
| return fn( |
| // i.e. (rf: RenderFlags, ctx: any) |
| [new FnParam(RENDER_FLAGS, NUMBER_TYPE), new FnParam(CONTEXT_NAME, null)], __spread(this._prefixCode, creationBlock, updateBlock), INFERRED_TYPE, null, this.templateName); |
| }; |
| // LocalResolver |
| TemplateDefinitionBuilder.prototype.getLocal = function (name) { return this._bindingScope.get(name); }; |
| // LocalResolver |
| TemplateDefinitionBuilder.prototype.notifyImplicitReceiverUse = function () { this._bindingScope.notifyImplicitReceiverUse(); }; |
| TemplateDefinitionBuilder.prototype.i18nTranslate = function (message, params, ref, transformFn) { |
| var _a; |
| if (params === void 0) { params = {}; } |
| var _ref = ref || variable(this.constantPool.uniqueName(TRANSLATION_PREFIX)); |
| // Closure Compiler requires const names to start with `MSG_` but disallows any other const to |
| // start with `MSG_`. We define a variable starting with `MSG_` just for the `goog.getMsg` call |
| var closureVar = this.i18nGenerateClosureVar(message.id); |
| var _params = {}; |
| if (params && Object.keys(params).length) { |
| Object.keys(params).forEach(function (key) { return _params[formatI18nPlaceholderName(key)] = params[key]; }); |
| } |
| var meta = metaFromI18nMessage(message); |
| var content = getSerializedI18nContent(message); |
| var statements = getTranslationDeclStmts(_ref, closureVar, content, meta, _params, transformFn); |
| (_a = this.constantPool.statements).push.apply(_a, __spread(statements)); |
| return _ref; |
| }; |
| TemplateDefinitionBuilder.prototype.i18nAppendBindings = function (expressions) { |
| var _this = this; |
| if (expressions.length > 0) { |
| expressions.forEach(function (expression) { return _this.i18n.appendBinding(expression); }); |
| } |
| }; |
| TemplateDefinitionBuilder.prototype.i18nBindProps = function (props) { |
| var _this = this; |
| var bound = {}; |
| Object.keys(props).forEach(function (key) { |
| var prop = props[key]; |
| if (prop instanceof Text) { |
| bound[key] = literal(prop.value); |
| } |
| else { |
| var value = prop.value.visit(_this._valueConverter); |
| _this.allocateBindingSlots(value); |
| if (value instanceof Interpolation) { |
| var strings = value.strings, expressions = value.expressions; |
| var _a = _this.i18n, id = _a.id, bindings = _a.bindings; |
| var label = assembleI18nBoundString(strings, bindings.size, id); |
| _this.i18nAppendBindings(expressions); |
| bound[key] = literal(label); |
| } |
| } |
| }); |
| return bound; |
| }; |
| TemplateDefinitionBuilder.prototype.i18nGenerateClosureVar = function (messageId) { |
| var name; |
| var suffix = this.fileBasedI18nSuffix.toUpperCase(); |
| if (this.i18nUseExternalIds) { |
| var prefix = getTranslationConstPrefix("EXTERNAL_"); |
| var uniqueSuffix = this.constantPool.uniqueName(suffix); |
| name = "" + prefix + sanitizeIdentifier(messageId) + "$$" + uniqueSuffix; |
| } |
| else { |
| var prefix = getTranslationConstPrefix(suffix); |
| name = this.constantPool.uniqueName(prefix); |
| } |
| return variable(name); |
| }; |
| TemplateDefinitionBuilder.prototype.i18nUpdateRef = function (context) { |
| var icus = context.icus, meta = context.meta, isRoot = context.isRoot, isResolved = context.isResolved, isEmitted = context.isEmitted; |
| if (isRoot && isResolved && !isEmitted && !isSingleI18nIcu(meta)) { |
| context.isEmitted = true; |
| var placeholders = context.getSerializedPlaceholders(); |
| var icuMapping_1 = {}; |
| var params_1 = placeholders.size ? placeholdersToParams(placeholders) : {}; |
| if (icus.size) { |
| icus.forEach(function (refs, key) { |
| if (refs.length === 1) { |
| // if we have one ICU defined for a given |
| // placeholder - just output its reference |
| params_1[key] = refs[0]; |
| } |
| else { |
| // ... otherwise we need to activate post-processing |
| // to replace ICU placeholders with proper values |
| var placeholder = wrapI18nPlaceholder("" + I18N_ICU_MAPPING_PREFIX + key); |
| params_1[key] = literal(placeholder); |
| icuMapping_1[key] = literalArr(refs); |
| } |
| }); |
| } |
| // translation requires post processing in 2 cases: |
| // - if we have placeholders with multiple values (ex. `START_DIV`: [�#1�, �#2�, ...]) |
| // - if we have multiple ICUs that refer to the same placeholder name |
| var needsPostprocessing = Array.from(placeholders.values()).some(function (value) { return value.length > 1; }) || |
| Object.keys(icuMapping_1).length; |
| var transformFn = void 0; |
| if (needsPostprocessing) { |
| transformFn = function (raw) { |
| var args = [raw]; |
| if (Object.keys(icuMapping_1).length) { |
| args.push(mapLiteral(icuMapping_1, true)); |
| } |
| return instruction(null, Identifiers$1.i18nPostprocess, args); |
| }; |
| } |
| this.i18nTranslate(meta, params_1, context.ref, transformFn); |
| } |
| }; |
| TemplateDefinitionBuilder.prototype.i18nStart = function (span, meta, selfClosing) { |
| if (span === void 0) { span = null; } |
| var index = this.allocateDataSlot(); |
| if (this.i18nContext) { |
| this.i18n = this.i18nContext.forkChildContext(index, this.templateIndex, meta); |
| } |
| else { |
| var ref_1 = variable(this.constantPool.uniqueName(TRANSLATION_PREFIX)); |
| this.i18n = new I18nContext(index, ref_1, 0, this.templateIndex, meta); |
| } |
| // generate i18nStart instruction |
| var _a = this.i18n, id = _a.id, ref = _a.ref; |
| var params = [literal(index), ref]; |
| if (id > 0) { |
| // do not push 3rd argument (sub-block id) |
| // into i18nStart call for top level i18n context |
| params.push(literal(id)); |
| } |
| this.creationInstruction(span, selfClosing ? Identifiers$1.i18n : Identifiers$1.i18nStart, params); |
| }; |
| TemplateDefinitionBuilder.prototype.i18nEnd = function (span, selfClosing) { |
| var _this = this; |
| if (span === void 0) { span = null; } |
| if (!this.i18n) { |
| throw new Error('i18nEnd is executed with no i18n context present'); |
| } |
| if (this.i18nContext) { |
| this.i18nContext.reconcileChildContext(this.i18n); |
| this.i18nUpdateRef(this.i18nContext); |
| } |
| else { |
| this.i18nUpdateRef(this.i18n); |
| } |
| // setup accumulated bindings |
| var _a = this.i18n, index = _a.index, bindings = _a.bindings; |
| if (bindings.size) { |
| var chainBindings_1 = []; |
| bindings.forEach(function (binding) { |
| chainBindings_1.push({ sourceSpan: span, value: function () { return _this.convertPropertyBinding(binding); } }); |
| }); |
| this.updateInstructionChain(index, Identifiers$1.i18nExp, chainBindings_1); |
| this.updateInstruction(index, span, Identifiers$1.i18nApply, [literal(index)]); |
| } |
| if (!selfClosing) { |
| this.creationInstruction(span, Identifiers$1.i18nEnd); |
| } |
| this.i18n = null; // reset local i18n context |
| }; |
| TemplateDefinitionBuilder.prototype.visitContent = function (ngContent) { |
| var slot = this.allocateDataSlot(); |
| var projectionSlotIdx = this._ngContentSelectorsOffset + this._ngContentReservedSlots.length; |
| var parameters = [literal(slot)]; |
| var attributes = []; |
| this._ngContentReservedSlots.push(ngContent.selector); |
| ngContent.attributes.forEach(function (attribute) { |
| var name = attribute.name, value = attribute.value; |
| if (name === NG_PROJECT_AS_ATTR_NAME) { |
| attributes.push.apply(attributes, __spread(getNgProjectAsLiteral(attribute))); |
| } |
| else if (name.toLowerCase() !== NG_CONTENT_SELECT_ATTR$1) { |
| attributes.push(literal(name), literal(value)); |
| } |
| }); |
| if (attributes.length > 0) { |
| parameters.push(literal(projectionSlotIdx), literalArr(attributes)); |
| } |
| else if (projectionSlotIdx !== 0) { |
| parameters.push(literal(projectionSlotIdx)); |
| } |
| this.creationInstruction(ngContent.sourceSpan, Identifiers$1.projection, parameters); |
| if (this.i18n) { |
| this.i18n.appendProjection(ngContent.i18n, slot); |
| } |
| }; |
| TemplateDefinitionBuilder.prototype.getNamespaceInstruction = function (namespaceKey) { |
| switch (namespaceKey) { |
| case 'math': |
| return Identifiers$1.namespaceMathML; |
| case 'svg': |
| return Identifiers$1.namespaceSVG; |
| default: |
| return Identifiers$1.namespaceHTML; |
| } |
| }; |
| TemplateDefinitionBuilder.prototype.addNamespaceInstruction = function (nsInstruction, element) { |
| this._namespace = nsInstruction; |
| this.creationInstruction(element.sourceSpan, nsInstruction); |
| }; |
| TemplateDefinitionBuilder.prototype.visitElement = function (element) { |
| var _this = this; |
| var e_1, _a; |
| var elementIndex = this.allocateDataSlot(); |
| var stylingBuilder = new StylingBuilder(literal(elementIndex), null); |
| var isNonBindableMode = false; |
| var isI18nRootElement = isI18nRootNode(element.i18n) && !isSingleI18nIcu(element.i18n); |
| if (isI18nRootElement && this.i18n) { |
| throw new Error("Could not mark an element as translatable inside of a translatable section"); |
| } |
| var i18nAttrs = []; |
| var outputAttrs = []; |
| var _b = __read(splitNsName(element.name), 2), namespaceKey = _b[0], elementName = _b[1]; |
| var isNgContainer$1 = isNgContainer(element.name); |
| try { |
| // Handle styling, i18n, ngNonBindable attributes |
| for (var _c = __values(element.attributes), _d = _c.next(); !_d.done; _d = _c.next()) { |
| var attr = _d.value; |
| var name_1 = attr.name, value = attr.value; |
| if (name_1 === NON_BINDABLE_ATTR) { |
| isNonBindableMode = true; |
| } |
| else if (name_1 === 'style') { |
| stylingBuilder.registerStyleAttr(value); |
| } |
| else if (name_1 === 'class') { |
| stylingBuilder.registerClassAttr(value); |
| } |
| else { |
| if (attr.i18n) { |
| // Place attributes into a separate array for i18n processing, but also keep such |
| // attributes in the main list to make them available for directive matching at runtime. |
| // TODO(FW-1248): prevent attributes duplication in `i18nAttributes` and `elementStart` |
| // arguments |
| i18nAttrs.push(attr); |
| } |
| else { |
| outputAttrs.push(attr); |
| } |
| } |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (_d && !_d.done && (_a = _c.return)) _a.call(_c); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| // Match directives on non i18n attributes |
| this.matchDirectives(element.name, element); |
| // Regular element or ng-container creation mode |
| var parameters = [literal(elementIndex)]; |
| if (!isNgContainer$1) { |
| parameters.push(literal(elementName)); |
| } |
| // Add the attributes |
| var attributes = []; |
| var allOtherInputs = []; |
| element.inputs.forEach(function (input) { |
| var stylingInputWasSet = stylingBuilder.registerBoundInput(input); |
| if (!stylingInputWasSet) { |
| if (input.type === 0 /* Property */ && input.i18n) { |
| // Place attributes into a separate array for i18n processing, but also keep such |
| // attributes in the main list to make them available for directive matching at runtime. |
| // TODO(FW-1248): prevent attributes duplication in `i18nAttributes` and `elementStart` |
| // arguments |
| i18nAttrs.push(input); |
| } |
| else { |
| allOtherInputs.push(input); |
| } |
| } |
| }); |
| outputAttrs.forEach(function (attr) { |
| if (attr.name === NG_PROJECT_AS_ATTR_NAME) { |
| attributes.push.apply(attributes, __spread(getNgProjectAsLiteral(attr))); |
| } |
| else { |
| attributes.push.apply(attributes, __spread(getAttributeNameLiterals(attr.name), [literal(attr.value)])); |
| } |
| }); |
| // add attributes for directive and projection matching purposes |
| attributes.push.apply(attributes, __spread(this.prepareNonRenderAttrs(allOtherInputs, element.outputs, stylingBuilder, [], i18nAttrs))); |
| parameters.push(this.toAttrsParam(attributes)); |
| // local refs (ex.: <div #foo #bar="baz">) |
| parameters.push(this.prepareRefsParameter(element.references)); |
| var wasInNamespace = this._namespace; |
| var currentNamespace = this.getNamespaceInstruction(namespaceKey); |
| // If the namespace is changing now, include an instruction to change it |
| // during element creation. |
| if (currentNamespace !== wasInNamespace) { |
| this.addNamespaceInstruction(currentNamespace, element); |
| } |
| if (this.i18n) { |
| this.i18n.appendElement(element.i18n, elementIndex); |
| } |
| var hasChildren = function () { |
| if (!isI18nRootElement && _this.i18n) { |
| // we do not append text node instructions and ICUs inside i18n section, |
| // so we exclude them while calculating whether current element has children |
| return !hasTextChildrenOnly(element.children); |
| } |
| return element.children.length > 0; |
| }; |
| var createSelfClosingInstruction = !stylingBuilder.hasBindings && !isNgContainer$1 && |
| element.outputs.length === 0 && i18nAttrs.length === 0 && !hasChildren(); |
| var createSelfClosingI18nInstruction = !createSelfClosingInstruction && |
| !stylingBuilder.hasBindings && hasTextChildrenOnly(element.children); |
| if (createSelfClosingInstruction) { |
| this.creationInstruction(element.sourceSpan, Identifiers$1.element, trimTrailingNulls(parameters)); |
| } |
| else { |
| this.creationInstruction(element.sourceSpan, isNgContainer$1 ? Identifiers$1.elementContainerStart : Identifiers$1.elementStart, trimTrailingNulls(parameters)); |
| if (isNonBindableMode) { |
| this.creationInstruction(element.sourceSpan, Identifiers$1.disableBindings); |
| } |
| // process i18n element attributes |
| if (i18nAttrs.length) { |
| var hasBindings_1 = false; |
| var i18nAttrArgs_1 = []; |
| var bindings_1 = []; |
| i18nAttrs.forEach(function (attr) { |
| var message = attr.i18n; |
| if (attr instanceof TextAttribute) { |
| i18nAttrArgs_1.push(literal(attr.name), _this.i18nTranslate(message)); |
| } |
| else { |
| var converted = attr.value.visit(_this._valueConverter); |
| _this.allocateBindingSlots(converted); |
| if (converted instanceof Interpolation) { |
| var placeholders = assembleBoundTextPlaceholders(message); |
| var params = placeholdersToParams(placeholders); |
| i18nAttrArgs_1.push(literal(attr.name), _this.i18nTranslate(message, params)); |
| converted.expressions.forEach(function (expression) { |
| hasBindings_1 = true; |
| bindings_1.push({ |
| sourceSpan: element.sourceSpan, |
| value: function () { return _this.convertExpressionBinding(expression); } |
| }); |
| }); |
| } |
| } |
| }); |
| if (bindings_1.length) { |
| this.updateInstructionChain(elementIndex, Identifiers$1.i18nExp, bindings_1); |
| } |
| if (i18nAttrArgs_1.length) { |
| var index = literal(this.allocateDataSlot()); |
| var args = this.constantPool.getConstLiteral(literalArr(i18nAttrArgs_1), true); |
| this.creationInstruction(element.sourceSpan, Identifiers$1.i18nAttributes, [index, args]); |
| if (hasBindings_1) { |
| this.updateInstruction(elementIndex, element.sourceSpan, Identifiers$1.i18nApply, [index]); |
| } |
| } |
| } |
| // The style bindings code is placed into two distinct blocks within the template function AOT |
| // code: creation and update. The creation code contains the `styling` instructions |
| // which will apply the collected binding values to the element. `styling` is |
| // designed to run inside of `elementStart` and `elementEnd`. The update instructions |
| // (things like `styleProp`, `classProp`, etc..) are applied later on in this |
| // file |
| this.processStylingInstruction(elementIndex, stylingBuilder.buildStylingInstruction(element.sourceSpan, this.constantPool), true); |
| // Generate Listeners (outputs) |
| element.outputs.forEach(function (outputAst) { |
| _this.creationInstruction(outputAst.sourceSpan, Identifiers$1.listener, _this.prepareListenerParameter(element.name, outputAst, elementIndex)); |
| }); |
| // Note: it's important to keep i18n/i18nStart instructions after i18nAttributes and |
| // listeners, to make sure i18nAttributes instruction targets current element at runtime. |
| if (isI18nRootElement) { |
| this.i18nStart(element.sourceSpan, element.i18n, createSelfClosingI18nInstruction); |
| } |
| } |
| // the code here will collect all update-level styling instructions and add them to the |
| // update block of the template function AOT code. Instructions like `styleProp`, |
| // `styleMap`, `classMap`, `classProp` and `stylingApply` |
| // are all generated and assigned in the code below. |
| var stylingInstructions = stylingBuilder.buildUpdateLevelInstructions(this._valueConverter); |
| var limit = stylingInstructions.length - 1; |
| for (var i = 0; i <= limit; i++) { |
| var instruction_1 = stylingInstructions[i]; |
| this._bindingSlots += instruction_1.allocateBindingSlots; |
| this.processStylingInstruction(elementIndex, instruction_1, false); |
| } |
| // the reason why `undefined` is used is because the renderer understands this as a |
| // special value to symbolize that there is no RHS to this binding |
| // TODO (matsko): revisit this once FW-959 is approached |
| var emptyValueBindInstruction = literal(undefined); |
| var propertyBindings = []; |
| var attributeBindings = []; |
| // Generate element input bindings |
| allOtherInputs.forEach(function (input) { |
| var inputType = input.type; |
| if (inputType === 4 /* Animation */) { |
| var value_1 = input.value.visit(_this._valueConverter); |
| // animation bindings can be presented in the following formats: |
| // 1. [@binding]="fooExp" |
| // 2. [@binding]="{value:fooExp, params:{...}}" |
| // 3. [@binding] |
| // 4. @binding |
| // All formats will be valid for when a synthetic binding is created. |
| // The reasoning for this is because the renderer should get each |
| // synthetic binding value in the order of the array that they are |
| // defined in... |
| var hasValue_1 = value_1 instanceof LiteralPrimitive ? !!value_1.value : true; |
| _this.allocateBindingSlots(value_1); |
| propertyBindings.push({ |
| name: prepareSyntheticPropertyName(input.name), |
| sourceSpan: input.sourceSpan, |
| value: function () { return hasValue_1 ? _this.convertPropertyBinding(value_1) : emptyValueBindInstruction; } |
| }); |
| } |
| else { |
| // we must skip attributes with associated i18n context, since these attributes are handled |
| // separately and corresponding `i18nExp` and `i18nApply` instructions will be generated |
| if (input.i18n) |
| return; |
| var value_2 = input.value.visit(_this._valueConverter); |
| if (value_2 !== undefined) { |
| var params_2 = []; |
| var _a = __read(splitNsName(input.name), 2), attrNamespace = _a[0], attrName_1 = _a[1]; |
| var isAttributeBinding = inputType === 1 /* Attribute */; |
| var sanitizationRef = resolveSanitizationFn(input.securityContext, isAttributeBinding); |
| if (sanitizationRef) |
| params_2.push(sanitizationRef); |
| if (attrNamespace) { |
| var namespaceLiteral = literal(attrNamespace); |
| if (sanitizationRef) { |
| params_2.push(namespaceLiteral); |
| } |
| else { |
| // If there wasn't a sanitization ref, we need to add |
| // an extra param so that we can pass in the namespace. |
| params_2.push(literal(null), namespaceLiteral); |
| } |
| } |
| _this.allocateBindingSlots(value_2); |
| if (inputType === 0 /* Property */) { |
| if (value_2 instanceof Interpolation) { |
| // prop="{{value}}" and friends |
| _this.interpolatedUpdateInstruction(getPropertyInterpolationExpression(value_2), elementIndex, attrName_1, input, value_2, params_2); |
| } |
| else { |
| // [prop]="value" |
| // Collect all the properties so that we can chain into a single function at the end. |
| propertyBindings.push({ |
| name: attrName_1, |
| sourceSpan: input.sourceSpan, |
| value: function () { return _this.convertPropertyBinding(value_2); }, params: params_2 |
| }); |
| } |
| } |
| else if (inputType === 1 /* Attribute */) { |
| if (value_2 instanceof Interpolation && getInterpolationArgsLength(value_2) > 1) { |
| // attr.name="text{{value}}" and friends |
| _this.interpolatedUpdateInstruction(getAttributeInterpolationExpression(value_2), elementIndex, attrName_1, input, value_2, params_2); |
| } |
| else { |
| var boundValue_1 = value_2 instanceof Interpolation ? value_2.expressions[0] : value_2; |
| // [attr.name]="value" or attr.name="{{value}}" |
| // Collect the attribute bindings so that they can be chained at the end. |
| attributeBindings.push({ |
| name: attrName_1, |
| sourceSpan: input.sourceSpan, |
| value: function () { return _this.convertPropertyBinding(boundValue_1); }, params: params_2 |
| }); |
| } |
| } |
| else { |
| // class prop |
| _this.updateInstruction(elementIndex, input.sourceSpan, Identifiers$1.classProp, function () { |
| return __spread([ |
| literal(elementIndex), literal(attrName_1), _this.convertPropertyBinding(value_2) |
| ], params_2); |
| }); |
| } |
| } |
| } |
| }); |
| if (propertyBindings.length > 0) { |
| this.updateInstructionChain(elementIndex, Identifiers$1.property, propertyBindings); |
| } |
| if (attributeBindings.length > 0) { |
| this.updateInstructionChain(elementIndex, Identifiers$1.attribute, attributeBindings); |
| } |
| // Traverse element child nodes |
| visitAll(this, element.children); |
| if (!isI18nRootElement && this.i18n) { |
| this.i18n.appendElement(element.i18n, elementIndex, true); |
| } |
| if (!createSelfClosingInstruction) { |
| // Finish element construction mode. |
| var span = element.endSourceSpan || element.sourceSpan; |
| if (isI18nRootElement) { |
| this.i18nEnd(span, createSelfClosingI18nInstruction); |
| } |
| if (isNonBindableMode) { |
| this.creationInstruction(span, Identifiers$1.enableBindings); |
| } |
| this.creationInstruction(span, isNgContainer$1 ? Identifiers$1.elementContainerEnd : Identifiers$1.elementEnd); |
| } |
| }; |
| /** |
| * Adds an update instruction for an interpolated property or attribute, such as |
| * `prop="{{value}}"` or `attr.title="{{value}}"` |
| */ |
| TemplateDefinitionBuilder.prototype.interpolatedUpdateInstruction = function (instruction, elementIndex, attrName, input, value, params) { |
| var _this = this; |
| this.updateInstruction(elementIndex, input.sourceSpan, instruction, function () { return __spread([literal(attrName)], _this.getUpdateInstructionArguments(value), params); }); |
| }; |
| TemplateDefinitionBuilder.prototype.visitTemplate = function (template) { |
| var _this = this; |
| var NG_TEMPLATE_TAG_NAME = 'ng-template'; |
| var templateIndex = this.allocateDataSlot(); |
| if (this.i18n) { |
| this.i18n.appendTemplate(template.i18n, templateIndex); |
| } |
| var tagName = sanitizeIdentifier(template.tagName || ''); |
| var contextName = "" + this.contextName + (tagName ? '_' + tagName : '') + "_" + templateIndex; |
| var templateName = contextName + "_Template"; |
| var parameters = [ |
| literal(templateIndex), |
| variable(templateName), |
| // We don't care about the tag's namespace here, because we infer |
| // it based on the parent nodes inside the template instruction. |
| literal(template.tagName ? splitNsName(template.tagName)[1] : template.tagName), |
| ]; |
| // find directives matching on a given <ng-template> node |
| this.matchDirectives(NG_TEMPLATE_TAG_NAME, template); |
| // prepare attributes parameter (including attributes used for directive matching) |
| var attrsExprs = []; |
| template.attributes.forEach(function (a) { attrsExprs.push(asLiteral(a.name), asLiteral(a.value)); }); |
| attrsExprs.push.apply(attrsExprs, __spread(this.prepareNonRenderAttrs(template.inputs, template.outputs, undefined, template.templateAttrs))); |
| parameters.push(this.toAttrsParam(attrsExprs)); |
| // local refs (ex.: <ng-template #foo>) |
| if (template.references && template.references.length) { |
| parameters.push(this.prepareRefsParameter(template.references)); |
| parameters.push(importExpr(Identifiers$1.templateRefExtractor)); |
| } |
| // Create the template function |
| var templateVisitor = new TemplateDefinitionBuilder(this.constantPool, this._bindingScope, this.level + 1, contextName, this.i18n, templateIndex, templateName, this.directiveMatcher, this.directives, this.pipeTypeByName, this.pipes, this._namespace, this.fileBasedI18nSuffix, this.i18nUseExternalIds); |
| // Nested templates must not be visited until after their parent templates have completed |
| // processing, so they are queued here until after the initial pass. Otherwise, we wouldn't |
| // be able to support bindings in nested templates to local refs that occur after the |
| // template definition. e.g. <div *ngIf="showing">{{ foo }}</div> <div #foo></div> |
| this._nestedTemplateFns.push(function () { |
| var _a; |
| var templateFunctionExpr = templateVisitor.buildTemplateFunction(template.children, template.variables, _this._ngContentReservedSlots.length + _this._ngContentSelectorsOffset, template.i18n); |
| _this.constantPool.statements.push(templateFunctionExpr.toDeclStmt(templateName, null)); |
| if (templateVisitor._ngContentReservedSlots.length) { |
| (_a = _this._ngContentReservedSlots).push.apply(_a, __spread(templateVisitor._ngContentReservedSlots)); |
| } |
| }); |
| // e.g. template(1, MyComp_Template_1) |
| this.creationInstruction(template.sourceSpan, Identifiers$1.templateCreate, function () { |
| parameters.splice(2, 0, literal(templateVisitor.getConstCount()), literal(templateVisitor.getVarCount())); |
| return trimTrailingNulls(parameters); |
| }); |
| // handle property bindings e.g. ɵɵproperty('ngForOf', ctx.items), et al; |
| this.templatePropertyBindings(templateIndex, template.templateAttrs); |
| // Only add normal input/output binding instructions on explicit ng-template elements. |
| if (template.tagName === NG_TEMPLATE_TAG_NAME) { |
| // Add the input bindings |
| this.templatePropertyBindings(templateIndex, template.inputs); |
| // Generate listeners for directive output |
| template.outputs.forEach(function (outputAst) { |
| _this.creationInstruction(outputAst.sourceSpan, Identifiers$1.listener, _this.prepareListenerParameter('ng_template', outputAst, templateIndex)); |
| }); |
| } |
| }; |
| TemplateDefinitionBuilder.prototype.visitBoundText = function (text) { |
| var _this = this; |
| if (this.i18n) { |
| var value_3 = text.value.visit(this._valueConverter); |
| this.allocateBindingSlots(value_3); |
| if (value_3 instanceof Interpolation) { |
| this.i18n.appendBoundText(text.i18n); |
| this.i18nAppendBindings(value_3.expressions); |
| } |
| return; |
| } |
| var nodeIndex = this.allocateDataSlot(); |
| this.creationInstruction(text.sourceSpan, Identifiers$1.text, [literal(nodeIndex)]); |
| var value = text.value.visit(this._valueConverter); |
| this.allocateBindingSlots(value); |
| if (value instanceof Interpolation) { |
| this.updateInstruction(nodeIndex, text.sourceSpan, getTextInterpolationExpression(value), function () { return _this.getUpdateInstructionArguments(value); }); |
| } |
| else { |
| this.updateInstruction(nodeIndex, text.sourceSpan, Identifiers$1.textBinding, function () { return [_this.convertPropertyBinding(value)]; }); |
| } |
| }; |
| TemplateDefinitionBuilder.prototype.visitText = function (text) { |
| // when a text element is located within a translatable |
| // block, we exclude this text element from instructions set, |
| // since it will be captured in i18n content and processed at runtime |
| if (!this.i18n) { |
| this.creationInstruction(text.sourceSpan, Identifiers$1.text, [literal(this.allocateDataSlot()), literal(text.value)]); |
| } |
| }; |
| TemplateDefinitionBuilder.prototype.visitIcu = function (icu) { |
| var initWasInvoked = false; |
| // if an ICU was created outside of i18n block, we still treat |
| // it as a translatable entity and invoke i18nStart and i18nEnd |
| // to generate i18n context and the necessary instructions |
| if (!this.i18n) { |
| initWasInvoked = true; |
| this.i18nStart(null, icu.i18n, true); |
| } |
| var i18n = this.i18n; |
| var vars = this.i18nBindProps(icu.vars); |
| var placeholders = this.i18nBindProps(icu.placeholders); |
| // output ICU directly and keep ICU reference in context |
| var message = icu.i18n; |
| var transformFn = function (raw) { |
| return instruction(null, Identifiers$1.i18nPostprocess, [raw, mapLiteral(vars, true)]); |
| }; |
| // in case the whole i18n message is a single ICU - we do not need to |
| // create a separate top-level translation, we can use the root ref instead |
| // and make this ICU a top-level translation |
| if (isSingleI18nIcu(i18n.meta)) { |
| this.i18nTranslate(message, placeholders, i18n.ref, transformFn); |
| } |
| else { |
| // output ICU directly and keep ICU reference in context |
| var ref = this.i18nTranslate(message, placeholders, undefined, transformFn); |
| i18n.appendIcu(icuFromI18nMessage(message).name, ref); |
| } |
| if (initWasInvoked) { |
| this.i18nEnd(null, true); |
| } |
| return null; |
| }; |
| TemplateDefinitionBuilder.prototype.allocateDataSlot = function () { return this._dataIndex++; }; |
| TemplateDefinitionBuilder.prototype.getConstCount = function () { return this._dataIndex; }; |
| TemplateDefinitionBuilder.prototype.getVarCount = function () { return this._pureFunctionSlots; }; |
| TemplateDefinitionBuilder.prototype.getNgContentSelectors = function () { |
| return this._ngContentReservedSlots.length ? |
| this.constantPool.getConstLiteral(asLiteral(this._ngContentReservedSlots), true) : |
| null; |
| }; |
| TemplateDefinitionBuilder.prototype.bindingContext = function () { return "" + this._bindingContext++; }; |
| TemplateDefinitionBuilder.prototype.templatePropertyBindings = function (templateIndex, attrs) { |
| var _this = this; |
| var propertyBindings = []; |
| attrs.forEach(function (input) { |
| if (input instanceof BoundAttribute) { |
| var value_4 = input.value.visit(_this._valueConverter); |
| if (value_4 !== undefined) { |
| _this.allocateBindingSlots(value_4); |
| propertyBindings.push({ |
| name: input.name, |
| sourceSpan: input.sourceSpan, |
| value: function () { return _this.convertPropertyBinding(value_4); } |
| }); |
| } |
| } |
| }); |
| if (propertyBindings.length > 0) { |
| this.updateInstructionChain(templateIndex, Identifiers$1.property, propertyBindings); |
| } |
| }; |
| // Bindings must only be resolved after all local refs have been visited, so all |
| // instructions are queued in callbacks that execute once the initial pass has completed. |
| // Otherwise, we wouldn't be able to support local refs that are defined after their |
| // bindings. e.g. {{ foo }} <div #foo></div> |
| TemplateDefinitionBuilder.prototype.instructionFn = function (fns, span, reference, paramsOrFn, prepend) { |
| if (prepend === void 0) { prepend = false; } |
| fns[prepend ? 'unshift' : 'push'](function () { |
| var params = Array.isArray(paramsOrFn) ? paramsOrFn : paramsOrFn(); |
| return instruction(span, reference, params).toStmt(); |
| }); |
| }; |
| TemplateDefinitionBuilder.prototype.processStylingInstruction = function (elementIndex, instruction, createMode) { |
| var _this = this; |
| if (instruction) { |
| var paramsFn = function () { return instruction.buildParams(function (value) { return _this.convertPropertyBinding(value); }); }; |
| if (createMode) { |
| this.creationInstruction(instruction.sourceSpan, instruction.reference, paramsFn); |
| } |
| else { |
| this.updateInstruction(elementIndex, instruction.sourceSpan, instruction.reference, paramsFn); |
| } |
| } |
| }; |
| TemplateDefinitionBuilder.prototype.creationInstruction = function (span, reference, paramsOrFn, prepend) { |
| this.instructionFn(this._creationCodeFns, span, reference, paramsOrFn || [], prepend); |
| }; |
| TemplateDefinitionBuilder.prototype.updateInstruction = function (nodeIndex, span, reference, paramsOrFn) { |
| this.addSelectInstructionIfNecessary(nodeIndex, span); |
| this.instructionFn(this._updateCodeFns, span, reference, paramsOrFn || []); |
| }; |
| TemplateDefinitionBuilder.prototype.updateInstructionChain = function (nodeIndex, reference, bindings) { |
| var span = bindings.length ? bindings[0].sourceSpan : null; |
| this.addSelectInstructionIfNecessary(nodeIndex, span); |
| this._updateCodeFns.push(function () { |
| var calls = bindings.map(function (property) { |
| var fnParams = __spread([property.value()], (property.params || [])); |
| if (property.name) { |
| fnParams.unshift(literal(property.name)); |
| } |
| return fnParams; |
| }); |
| return chainedInstruction(span, reference, calls).toStmt(); |
| }); |
| }; |
| TemplateDefinitionBuilder.prototype.addSelectInstructionIfNecessary = function (nodeIndex, span) { |
| if (this._lastNodeIndexWithFlush < nodeIndex) { |
| if (nodeIndex > 0) { |
| this.instructionFn(this._updateCodeFns, span, Identifiers$1.select, [literal(nodeIndex)]); |
| } |
| this._lastNodeIndexWithFlush = nodeIndex; |
| } |
| }; |
| TemplateDefinitionBuilder.prototype.allocatePureFunctionSlots = function (numSlots) { |
| var originalSlots = this._pureFunctionSlots; |
| this._pureFunctionSlots += numSlots; |
| return originalSlots; |
| }; |
| TemplateDefinitionBuilder.prototype.allocateBindingSlots = function (value) { |
| this._bindingSlots += value instanceof Interpolation ? value.expressions.length : 1; |
| }; |
| /** |
| * Gets an expression that refers to the implicit receiver. The implicit |
| * receiver is always the root level context. |
| */ |
| TemplateDefinitionBuilder.prototype.getImplicitReceiverExpr = function () { |
| if (this._implicitReceiverExpr) { |
| return this._implicitReceiverExpr; |
| } |
| return this._implicitReceiverExpr = this.level === 0 ? |
| variable(CONTEXT_NAME) : |
| this._bindingScope.getOrCreateSharedContextVar(0); |
| }; |
| TemplateDefinitionBuilder.prototype.convertExpressionBinding = function (value) { |
| var convertedPropertyBinding = convertPropertyBinding(this, this.getImplicitReceiverExpr(), value, this.bindingContext(), BindingForm.TrySimple); |
| return convertedPropertyBinding.currValExpr; |
| }; |
| TemplateDefinitionBuilder.prototype.convertPropertyBinding = function (value) { |
| var _a; |
| var interpolationFn = value instanceof Interpolation ? interpolate : function () { return error('Unexpected interpolation'); }; |
| var convertedPropertyBinding = convertPropertyBinding(this, this.getImplicitReceiverExpr(), value, this.bindingContext(), BindingForm.TrySimple, interpolationFn); |
| var valExpr = convertedPropertyBinding.currValExpr; |
| (_a = this._tempVariables).push.apply(_a, __spread(convertedPropertyBinding.stmts)); |
| return valExpr; |
| }; |
| /** |
| * Gets a list of argument expressions to pass to an update instruction expression. Also updates |
| * the temp variables state with temp variables that were identified as needing to be created |
| * while visiting the arguments. |
| * @param value The original expression we will be resolving an arguments list from. |
| */ |
| TemplateDefinitionBuilder.prototype.getUpdateInstructionArguments = function (value) { |
| var _a; |
| var _b = convertUpdateArguments(this, this.getImplicitReceiverExpr(), value, this.bindingContext()), args = _b.args, stmts = _b.stmts; |
| (_a = this._tempVariables).push.apply(_a, __spread(stmts)); |
| return args; |
| }; |
| TemplateDefinitionBuilder.prototype.matchDirectives = function (tagName, elOrTpl) { |
| var _this = this; |
| if (this.directiveMatcher) { |
| var selector = createCssSelector(tagName, getAttrsForDirectiveMatching(elOrTpl)); |
| this.directiveMatcher.match(selector, function (cssSelector, staticType) { _this.directives.add(staticType); }); |
| } |
| }; |
| /** |
| * Prepares all attribute expression values for the `TAttributes` array. |
| * |
| * The purpose of this function is to properly construct an attributes array that |
| * is passed into the `elementStart` (or just `element`) functions. Because there |
| * are many different types of attributes, the array needs to be constructed in a |
| * special way so that `elementStart` can properly evaluate them. |
| * |
| * The format looks like this: |
| * |
| * ``` |
| * attrs = [prop, value, prop2, value2, |
| * CLASSES, class1, class2, |
| * STYLES, style1, value1, style2, value2, |
| * BINDINGS, name1, name2, name3, |
| * TEMPLATE, name4, name5, name6, |
| * I18N, name7, name8, ...] |
| * ``` |
| * |
| * Note that this function will fully ignore all synthetic (@foo) attribute values |
| * because those values are intended to always be generated as property instructions. |
| */ |
| TemplateDefinitionBuilder.prototype.prepareNonRenderAttrs = function (inputs, outputs, styles, templateAttrs, i18nAttrs) { |
| if (templateAttrs === void 0) { templateAttrs = []; } |
| if (i18nAttrs === void 0) { i18nAttrs = []; } |
| var alreadySeen = new Set(); |
| var attrExprs = []; |
| function addAttrExpr(key, value) { |
| if (typeof key === 'string') { |
| if (!alreadySeen.has(key)) { |
| attrExprs.push.apply(attrExprs, __spread(getAttributeNameLiterals(key))); |
| value !== undefined && attrExprs.push(value); |
| alreadySeen.add(key); |
| } |
| } |
| else { |
| attrExprs.push(literal(key)); |
| } |
| } |
| // it's important that this occurs before BINDINGS and TEMPLATE because once `elementStart` |
| // comes across the BINDINGS or TEMPLATE markers then it will continue reading each value as |
| // as single property value cell by cell. |
| if (styles) { |
| styles.populateInitialStylingAttrs(attrExprs); |
| } |
| if (inputs.length || outputs.length) { |
| var attrsStartIndex = attrExprs.length; |
| for (var i = 0; i < inputs.length; i++) { |
| var input = inputs[i]; |
| if (input.type !== 4 /* Animation */) { |
| addAttrExpr(input.name); |
| } |
| } |
| for (var i = 0; i < outputs.length; i++) { |
| var output = outputs[i]; |
| if (output.type !== 1 /* Animation */) { |
| addAttrExpr(output.name); |
| } |
| } |
| // this is a cheap way of adding the marker only after all the input/output |
| // values have been filtered (by not including the animation ones) and added |
| // to the expressions. The marker is important because it tells the runtime |
| // code that this is where attributes without values start... |
| if (attrExprs.length) { |
| attrExprs.splice(attrsStartIndex, 0, literal(3 /* Bindings */)); |
| } |
| } |
| if (templateAttrs.length) { |
| attrExprs.push(literal(4 /* Template */)); |
| templateAttrs.forEach(function (attr) { return addAttrExpr(attr.name); }); |
| } |
| if (i18nAttrs.length) { |
| attrExprs.push(literal(6 /* I18n */)); |
| i18nAttrs.forEach(function (attr) { return addAttrExpr(attr.name); }); |
| } |
| return attrExprs; |
| }; |
| TemplateDefinitionBuilder.prototype.toAttrsParam = function (attrsExprs) { |
| return attrsExprs.length > 0 ? |
| this.constantPool.getConstLiteral(literalArr(attrsExprs), true) : |
| TYPED_NULL_EXPR; |
| }; |
| TemplateDefinitionBuilder.prototype.prepareRefsParameter = function (references) { |
| var _this = this; |
| if (!references || references.length === 0) { |
| return TYPED_NULL_EXPR; |
| } |
| var refsParam = flatten(references.map(function (reference) { |
| var slot = _this.allocateDataSlot(); |
| // Generate the update temporary. |
| var variableName = _this._bindingScope.freshReferenceName(); |
| var retrievalLevel = _this.level; |
| var lhs = variable(variableName); |
| _this._bindingScope.set(retrievalLevel, reference.name, lhs, 0 /* DEFAULT */, function (scope, relativeLevel) { |
| // e.g. nextContext(2); |
| var nextContextStmt = relativeLevel > 0 ? [generateNextContextExpr(relativeLevel).toStmt()] : []; |
| // e.g. const $foo$ = reference(1); |
| var refExpr = lhs.set(importExpr(Identifiers$1.reference).callFn([literal(slot)])); |
| return nextContextStmt.concat(refExpr.toConstDecl()); |
| }, true); |
| return [reference.name, reference.value]; |
| })); |
| return this.constantPool.getConstLiteral(asLiteral(refsParam), true); |
| }; |
| TemplateDefinitionBuilder.prototype.prepareListenerParameter = function (tagName, outputAst, index) { |
| var _this = this; |
| return function () { |
| var eventName = outputAst.name; |
| var bindingFnName = outputAst.type === 1 /* Animation */ ? |
| // synthetic @listener.foo values are treated the exact same as are standard listeners |
| prepareSyntheticListenerFunctionName(eventName, outputAst.phase) : |
| sanitizeIdentifier(eventName); |
| var handlerName = _this.templateName + "_" + tagName + "_" + bindingFnName + "_" + index + "_listener"; |
| var scope = _this._bindingScope.nestedScope(_this._bindingScope.bindingLevel); |
| return prepareEventListenerParameters(outputAst, handlerName, scope); |
| }; |
| }; |
| return TemplateDefinitionBuilder; |
| }()); |
| var ValueConverter = /** @class */ (function (_super) { |
| __extends(ValueConverter, _super); |
| function ValueConverter(constantPool, allocateSlot, allocatePureFunctionSlots, definePipe) { |
| var _this = _super.call(this) || this; |
| _this.constantPool = constantPool; |
| _this.allocateSlot = allocateSlot; |
| _this.allocatePureFunctionSlots = allocatePureFunctionSlots; |
| _this.definePipe = definePipe; |
| _this._pipeBindExprs = []; |
| return _this; |
| } |
| // AstMemoryEfficientTransformer |
| ValueConverter.prototype.visitPipe = function (pipe, context) { |
| // Allocate a slot to create the pipe |
| var slot = this.allocateSlot(); |
| var slotPseudoLocal = "PIPE:" + slot; |
| // Allocate one slot for the result plus one slot per pipe argument |
| var pureFunctionSlot = this.allocatePureFunctionSlots(2 + pipe.args.length); |
| var target = new PropertyRead(pipe.span, new ImplicitReceiver(pipe.span), slotPseudoLocal); |
| var _a = pipeBindingCallInfo(pipe.args), identifier = _a.identifier, isVarLength = _a.isVarLength; |
| this.definePipe(pipe.name, slotPseudoLocal, slot, importExpr(identifier)); |
| var args = __spread([pipe.exp], pipe.args); |
| var convertedArgs = isVarLength ? this.visitAll([new LiteralArray(pipe.span, args)]) : this.visitAll(args); |
| var pipeBindExpr = new FunctionCall(pipe.span, target, __spread([ |
| new LiteralPrimitive(pipe.span, slot), |
| new LiteralPrimitive(pipe.span, pureFunctionSlot) |
| ], convertedArgs)); |
| this._pipeBindExprs.push(pipeBindExpr); |
| return pipeBindExpr; |
| }; |
| ValueConverter.prototype.updatePipeSlotOffsets = function (bindingSlots) { |
| this._pipeBindExprs.forEach(function (pipe) { |
| // update the slot offset arg (index 1) to account for binding slots |
| var slotOffset = pipe.args[1]; |
| slotOffset.value += bindingSlots; |
| }); |
| }; |
| ValueConverter.prototype.visitLiteralArray = function (array, context) { |
| var _this = this; |
| return new BuiltinFunctionCall(array.span, this.visitAll(array.expressions), function (values) { |
| // If the literal has calculated (non-literal) elements transform it into |
| // calls to literal factories that compose the literal and will cache intermediate |
| // values. Otherwise, just return an literal array that contains the values. |
| var literal = literalArr(values); |
| return values.every(function (a) { return a.isConstant(); }) ? |
| _this.constantPool.getConstLiteral(literal, true) : |
| getLiteralFactory(_this.constantPool, literal, _this.allocatePureFunctionSlots); |
| }); |
| }; |
| ValueConverter.prototype.visitLiteralMap = function (map, context) { |
| var _this = this; |
| return new BuiltinFunctionCall(map.span, this.visitAll(map.values), function (values) { |
| // If the literal has calculated (non-literal) elements transform it into |
| // calls to literal factories that compose the literal and will cache intermediate |
| // values. Otherwise, just return an literal array that contains the values. |
| var literal = literalMap(values.map(function (value, index) { return ({ key: map.keys[index].key, value: value, quoted: map.keys[index].quoted }); })); |
| return values.every(function (a) { return a.isConstant(); }) ? |
| _this.constantPool.getConstLiteral(literal, true) : |
| getLiteralFactory(_this.constantPool, literal, _this.allocatePureFunctionSlots); |
| }); |
| }; |
| return ValueConverter; |
| }(AstMemoryEfficientTransformer)); |
| // Pipes always have at least one parameter, the value they operate on |
| var pipeBindingIdentifiers = [Identifiers$1.pipeBind1, Identifiers$1.pipeBind2, Identifiers$1.pipeBind3, Identifiers$1.pipeBind4]; |
| function pipeBindingCallInfo(args) { |
| var identifier = pipeBindingIdentifiers[args.length]; |
| return { |
| identifier: identifier || Identifiers$1.pipeBindV, |
| isVarLength: !identifier, |
| }; |
| } |
| var pureFunctionIdentifiers = [ |
| Identifiers$1.pureFunction0, Identifiers$1.pureFunction1, Identifiers$1.pureFunction2, Identifiers$1.pureFunction3, Identifiers$1.pureFunction4, |
| Identifiers$1.pureFunction5, Identifiers$1.pureFunction6, Identifiers$1.pureFunction7, Identifiers$1.pureFunction8 |
| ]; |
| function pureFunctionCallInfo(args) { |
| var identifier = pureFunctionIdentifiers[args.length]; |
| return { |
| identifier: identifier || Identifiers$1.pureFunctionV, |
| isVarLength: !identifier, |
| }; |
| } |
| function instruction(span, reference, params) { |
| return importExpr(reference, null, span).callFn(params, span); |
| } |
| function chainedInstruction(span, reference, calls) { |
| var expression = importExpr(reference, null, span); |
| if (calls.length > 0) { |
| for (var i = 0; i < calls.length; i++) { |
| expression = expression.callFn(calls[i], span); |
| } |
| } |
| else { |
| // Add a blank invocation, in case the `calls` array is empty. |
| expression = expression.callFn([], span); |
| } |
| return expression; |
| } |
| // e.g. x(2); |
| function generateNextContextExpr(relativeLevelDiff) { |
| return importExpr(Identifiers$1.nextContext) |
| .callFn(relativeLevelDiff > 1 ? [literal(relativeLevelDiff)] : []); |
| } |
| function getLiteralFactory(constantPool, literal$1, allocateSlots) { |
| var _a = constantPool.getLiteralFactory(literal$1), literalFactory = _a.literalFactory, literalFactoryArguments = _a.literalFactoryArguments; |
| // Allocate 1 slot for the result plus 1 per argument |
| var startSlot = allocateSlots(1 + literalFactoryArguments.length); |
| literalFactoryArguments.length > 0 || error("Expected arguments to a literal factory function"); |
| var _b = pureFunctionCallInfo(literalFactoryArguments), identifier = _b.identifier, isVarLength = _b.isVarLength; |
| // Literal factories are pure functions that only need to be re-invoked when the parameters |
| // change. |
| var args = [ |
| literal(startSlot), |
| literalFactory, |
| ]; |
| if (isVarLength) { |
| args.push(literalArr(literalFactoryArguments)); |
| } |
| else { |
| args.push.apply(args, __spread(literalFactoryArguments)); |
| } |
| return importExpr(identifier).callFn(args); |
| } |
| /** |
| * Gets an array of literals that can be added to an expression |
| * to represent the name and namespace of an attribute. E.g. |
| * `:xlink:href` turns into `[AttributeMarker.NamespaceURI, 'xlink', 'href']`. |
| * |
| * @param name Name of the attribute, including the namespace. |
| */ |
| function getAttributeNameLiterals(name) { |
| var _a = __read(splitNsName(name), 2), attributeNamespace = _a[0], attributeName = _a[1]; |
| var nameLiteral = literal(attributeName); |
| if (attributeNamespace) { |
| return [ |
| literal(0 /* NamespaceURI */), literal(attributeNamespace), nameLiteral |
| ]; |
| } |
| return [nameLiteral]; |
| } |
| /** The prefix used to get a shared context in BindingScope's map. */ |
| var SHARED_CONTEXT_KEY = '$$shared_ctx$$'; |
| var BindingScope = /** @class */ (function () { |
| function BindingScope(bindingLevel, parent) { |
| if (bindingLevel === void 0) { bindingLevel = 0; } |
| if (parent === void 0) { parent = null; } |
| this.bindingLevel = bindingLevel; |
| this.parent = parent; |
| /** Keeps a map from local variables to their BindingData. */ |
| this.map = new Map(); |
| this.referenceNameIndex = 0; |
| this.restoreViewVariable = null; |
| } |
| Object.defineProperty(BindingScope, "ROOT_SCOPE", { |
| get: function () { |
| if (!BindingScope._ROOT_SCOPE) { |
| BindingScope._ROOT_SCOPE = new BindingScope().set(0, '$event', variable('$event')); |
| } |
| return BindingScope._ROOT_SCOPE; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| BindingScope.prototype.get = function (name) { |
| var current = this; |
| while (current) { |
| var value = current.map.get(name); |
| if (value != null) { |
| if (current !== this) { |
| // make a local copy and reset the `declare` state |
| value = { |
| retrievalLevel: value.retrievalLevel, |
| lhs: value.lhs, |
| declareLocalCallback: value.declareLocalCallback, |
| declare: false, |
| priority: value.priority, |
| localRef: value.localRef |
| }; |
| // Cache the value locally. |
| this.map.set(name, value); |
| // Possibly generate a shared context var |
| this.maybeGenerateSharedContextVar(value); |
| this.maybeRestoreView(value.retrievalLevel, value.localRef); |
| } |
| if (value.declareLocalCallback && !value.declare) { |
| value.declare = true; |
| } |
| return value.lhs; |
| } |
| current = current.parent; |
| } |
| // If we get to this point, we are looking for a property on the top level component |
| // - If level === 0, we are on the top and don't need to re-declare `ctx`. |
| // - If level > 0, we are in an embedded view. We need to retrieve the name of the |
| // local var we used to store the component context, e.g. const $comp$ = x(); |
| return this.bindingLevel === 0 ? null : this.getComponentProperty(name); |
| }; |
| /** |
| * Create a local variable for later reference. |
| * |
| * @param retrievalLevel The level from which this value can be retrieved |
| * @param name Name of the variable. |
| * @param lhs AST representing the left hand side of the `let lhs = rhs;`. |
| * @param priority The sorting priority of this var |
| * @param declareLocalCallback The callback to invoke when declaring this local var |
| * @param localRef Whether or not this is a local ref |
| */ |
| BindingScope.prototype.set = function (retrievalLevel, name, lhs, priority, declareLocalCallback, localRef) { |
| if (priority === void 0) { priority = 0 /* DEFAULT */; } |
| if (this.map.has(name)) { |
| if (localRef) { |
| // Do not throw an error if it's a local ref and do not update existing value, |
| // so the first defined ref is always returned. |
| return this; |
| } |
| error("The name " + name + " is already defined in scope to be " + this.map.get(name)); |
| } |
| this.map.set(name, { |
| retrievalLevel: retrievalLevel, |
| lhs: lhs, |
| declare: false, |
| declareLocalCallback: declareLocalCallback, |
| priority: priority, |
| localRef: localRef || false |
| }); |
| return this; |
| }; |
| // Implemented as part of LocalResolver. |
| BindingScope.prototype.getLocal = function (name) { return this.get(name); }; |
| // Implemented as part of LocalResolver. |
| BindingScope.prototype.notifyImplicitReceiverUse = function () { |
| if (this.bindingLevel !== 0) { |
| // Since the implicit receiver is accessed in an embedded view, we need to |
| // ensure that we declare a shared context variable for the current template |
| // in the update variables. |
| this.map.get(SHARED_CONTEXT_KEY + 0).declare = true; |
| } |
| }; |
| BindingScope.prototype.nestedScope = function (level) { |
| var newScope = new BindingScope(level, this); |
| if (level > 0) |
| newScope.generateSharedContextVar(0); |
| return newScope; |
| }; |
| /** |
| * Gets or creates a shared context variable and returns its expression. Note that |
| * this does not mean that the shared variable will be declared. Variables in the |
| * binding scope will be only declared if they are used. |
| */ |
| BindingScope.prototype.getOrCreateSharedContextVar = function (retrievalLevel) { |
| var bindingKey = SHARED_CONTEXT_KEY + retrievalLevel; |
| if (!this.map.has(bindingKey)) { |
| this.generateSharedContextVar(retrievalLevel); |
| } |
| return this.map.get(bindingKey).lhs; |
| }; |
| BindingScope.prototype.getSharedContextName = function (retrievalLevel) { |
| var sharedCtxObj = this.map.get(SHARED_CONTEXT_KEY + retrievalLevel); |
| return sharedCtxObj && sharedCtxObj.declare ? sharedCtxObj.lhs : null; |
| }; |
| BindingScope.prototype.maybeGenerateSharedContextVar = function (value) { |
| if (value.priority === 1 /* CONTEXT */ && |
| value.retrievalLevel < this.bindingLevel) { |
| var sharedCtxObj = this.map.get(SHARED_CONTEXT_KEY + value.retrievalLevel); |
| if (sharedCtxObj) { |
| sharedCtxObj.declare = true; |
| } |
| else { |
| this.generateSharedContextVar(value.retrievalLevel); |
| } |
| } |
| }; |
| BindingScope.prototype.generateSharedContextVar = function (retrievalLevel) { |
| var lhs = variable(CONTEXT_NAME + this.freshReferenceName()); |
| this.map.set(SHARED_CONTEXT_KEY + retrievalLevel, { |
| retrievalLevel: retrievalLevel, |
| lhs: lhs, |
| declareLocalCallback: function (scope, relativeLevel) { |
| // const ctx_r0 = nextContext(2); |
| return [lhs.set(generateNextContextExpr(relativeLevel)).toConstDecl()]; |
| }, |
| declare: false, |
| priority: 2 /* SHARED_CONTEXT */, |
| localRef: false |
| }); |
| }; |
| BindingScope.prototype.getComponentProperty = function (name) { |
| var componentValue = this.map.get(SHARED_CONTEXT_KEY + 0); |
| componentValue.declare = true; |
| this.maybeRestoreView(0, false); |
| return componentValue.lhs.prop(name); |
| }; |
| BindingScope.prototype.maybeRestoreView = function (retrievalLevel, localRefLookup) { |
| // We want to restore the current view in listener fns if: |
| // 1 - we are accessing a value in a parent view, which requires walking the view tree rather |
| // than using the ctx arg. In this case, the retrieval and binding level will be different. |
| // 2 - we are looking up a local ref, which requires restoring the view where the local |
| // ref is stored |
| if (this.isListenerScope() && (retrievalLevel < this.bindingLevel || localRefLookup)) { |
| if (!this.parent.restoreViewVariable) { |
| // parent saves variable to generate a shared `const $s$ = getCurrentView();` instruction |
| this.parent.restoreViewVariable = variable(this.parent.freshReferenceName()); |
| } |
| this.restoreViewVariable = this.parent.restoreViewVariable; |
| } |
| }; |
| BindingScope.prototype.restoreViewStatement = function () { |
| // restoreView($state$); |
| return this.restoreViewVariable ? |
| [instruction(null, Identifiers$1.restoreView, [this.restoreViewVariable]).toStmt()] : |
| []; |
| }; |
| BindingScope.prototype.viewSnapshotStatements = function () { |
| // const $state$ = getCurrentView(); |
| var getCurrentViewInstruction = instruction(null, Identifiers$1.getCurrentView, []); |
| return this.restoreViewVariable ? |
| [this.restoreViewVariable.set(getCurrentViewInstruction).toConstDecl()] : |
| []; |
| }; |
| BindingScope.prototype.isListenerScope = function () { return this.parent && this.parent.bindingLevel === this.bindingLevel; }; |
| BindingScope.prototype.variableDeclarations = function () { |
| var _this = this; |
| var currentContextLevel = 0; |
| return Array.from(this.map.values()) |
| .filter(function (value) { return value.declare; }) |
| .sort(function (a, b) { return b.retrievalLevel - a.retrievalLevel || b.priority - a.priority; }) |
| .reduce(function (stmts, value) { |
| var levelDiff = _this.bindingLevel - value.retrievalLevel; |
| var currStmts = value.declareLocalCallback(_this, levelDiff - currentContextLevel); |
| currentContextLevel = levelDiff; |
| return stmts.concat(currStmts); |
| }, []); |
| }; |
| BindingScope.prototype.freshReferenceName = function () { |
| var current = this; |
| // Find the top scope as it maintains the global reference count |
| while (current.parent) |
| current = current.parent; |
| var ref = "" + REFERENCE_PREFIX + current.referenceNameIndex++; |
| return ref; |
| }; |
| return BindingScope; |
| }()); |
| /** |
| * Creates a `CssSelector` given a tag name and a map of attributes |
| */ |
| function createCssSelector(tag, attributes) { |
| var cssSelector = new CssSelector(); |
| cssSelector.setElement(tag); |
| Object.getOwnPropertyNames(attributes).forEach(function (name) { |
| var value = attributes[name]; |
| cssSelector.addAttribute(name, value); |
| if (name.toLowerCase() === 'class') { |
| var classes = value.trim().split(/\s+/); |
| classes.forEach(function (className) { return cssSelector.addClassName(className); }); |
| } |
| }); |
| return cssSelector; |
| } |
| /** |
| * Creates an array of expressions out of an `ngProjectAs` attributes |
| * which can be added to the instruction parameters. |
| */ |
| function getNgProjectAsLiteral(attribute) { |
| // Parse the attribute value into a CssSelectorList. Note that we only take the |
| // first selector, because we don't support multiple selectors in ngProjectAs. |
| var parsedR3Selector = parseSelectorToR3Selector(attribute.value)[0]; |
| return [literal(5 /* ProjectAs */), asLiteral(parsedR3Selector)]; |
| } |
| function interpolate(args) { |
| args = args.slice(1); // Ignore the length prefix added for render2 |
| switch (args.length) { |
| case 3: |
| return importExpr(Identifiers$1.interpolation1).callFn(args); |
| case 5: |
| return importExpr(Identifiers$1.interpolation2).callFn(args); |
| case 7: |
| return importExpr(Identifiers$1.interpolation3).callFn(args); |
| case 9: |
| return importExpr(Identifiers$1.interpolation4).callFn(args); |
| case 11: |
| return importExpr(Identifiers$1.interpolation5).callFn(args); |
| case 13: |
| return importExpr(Identifiers$1.interpolation6).callFn(args); |
| case 15: |
| return importExpr(Identifiers$1.interpolation7).callFn(args); |
| case 17: |
| return importExpr(Identifiers$1.interpolation8).callFn(args); |
| } |
| (args.length >= 19 && args.length % 2 == 1) || |
| error("Invalid interpolation argument length " + args.length); |
| return importExpr(Identifiers$1.interpolationV).callFn([literalArr(args)]); |
| } |
| /** |
| * Gets the instruction to generate for an interpolated property |
| * @param interpolation An Interpolation AST |
| */ |
| function getPropertyInterpolationExpression(interpolation) { |
| switch (getInterpolationArgsLength(interpolation)) { |
| case 1: |
| return Identifiers$1.propertyInterpolate; |
| case 3: |
| return Identifiers$1.propertyInterpolate1; |
| case 5: |
| return Identifiers$1.propertyInterpolate2; |
| case 7: |
| return Identifiers$1.propertyInterpolate3; |
| case 9: |
| return Identifiers$1.propertyInterpolate4; |
| case 11: |
| return Identifiers$1.propertyInterpolate5; |
| case 13: |
| return Identifiers$1.propertyInterpolate6; |
| case 15: |
| return Identifiers$1.propertyInterpolate7; |
| case 17: |
| return Identifiers$1.propertyInterpolate8; |
| default: |
| return Identifiers$1.propertyInterpolateV; |
| } |
| } |
| /** |
| * Gets the instruction to generate for an interpolated attribute |
| * @param interpolation An Interpolation AST |
| */ |
| function getAttributeInterpolationExpression(interpolation) { |
| switch (getInterpolationArgsLength(interpolation)) { |
| case 3: |
| return Identifiers$1.attributeInterpolate1; |
| case 5: |
| return Identifiers$1.attributeInterpolate2; |
| case 7: |
| return Identifiers$1.attributeInterpolate3; |
| case 9: |
| return Identifiers$1.attributeInterpolate4; |
| case 11: |
| return Identifiers$1.attributeInterpolate5; |
| case 13: |
| return Identifiers$1.attributeInterpolate6; |
| case 15: |
| return Identifiers$1.attributeInterpolate7; |
| case 17: |
| return Identifiers$1.attributeInterpolate8; |
| default: |
| return Identifiers$1.attributeInterpolateV; |
| } |
| } |
| /** |
| * Gets the instruction to generate for interpolated text. |
| * @param interpolation An Interpolation AST |
| */ |
| function getTextInterpolationExpression(interpolation) { |
| switch (getInterpolationArgsLength(interpolation)) { |
| case 1: |
| return Identifiers$1.textInterpolate; |
| case 3: |
| return Identifiers$1.textInterpolate1; |
| case 5: |
| return Identifiers$1.textInterpolate2; |
| case 7: |
| return Identifiers$1.textInterpolate3; |
| case 9: |
| return Identifiers$1.textInterpolate4; |
| case 11: |
| return Identifiers$1.textInterpolate5; |
| case 13: |
| return Identifiers$1.textInterpolate6; |
| case 15: |
| return Identifiers$1.textInterpolate7; |
| case 17: |
| return Identifiers$1.textInterpolate8; |
| default: |
| return Identifiers$1.textInterpolateV; |
| } |
| } |
| /** |
| * Gets the number of arguments expected to be passed to a generated instruction in the case of |
| * interpolation instructions. |
| * @param interpolation An interpolation ast |
| */ |
| function getInterpolationArgsLength(interpolation) { |
| var expressions = interpolation.expressions, strings = interpolation.strings; |
| if (expressions.length === 1 && strings.length === 2 && strings[0] === '' && strings[1] === '') { |
| // If the interpolation has one interpolated value, but the prefix and suffix are both empty |
| // strings, we only pass one argument, to a special instruction like `propertyInterpolate` or |
| // `textInterpolate`. |
| return 1; |
| } |
| else { |
| return expressions.length + strings.length; |
| } |
| } |
| /** |
| * Parse a template into render3 `Node`s and additional metadata, with no other dependencies. |
| * |
| * @param template text of the template to parse |
| * @param templateUrl URL to use for source mapping of the parsed template |
| * @param options options to modify how the template is parsed |
| */ |
| function parseTemplate(template, templateUrl, options) { |
| if (options === void 0) { options = {}; } |
| var interpolationConfig = options.interpolationConfig, preserveWhitespaces = options.preserveWhitespaces; |
| var bindingParser = makeBindingParser(interpolationConfig); |
| var htmlParser = new HtmlParser(); |
| var parseResult = htmlParser.parse(template, templateUrl, __assign({ leadingTriviaChars: LEADING_TRIVIA_CHARS }, options, { tokenizeExpansionForms: true })); |
| if (parseResult.errors && parseResult.errors.length > 0) { |
| return { errors: parseResult.errors, nodes: [], styleUrls: [], styles: [] }; |
| } |
| var rootNodes = parseResult.rootNodes; |
| // process i18n meta information (scan attributes, generate ids) |
| // before we run whitespace removal process, because existing i18n |
| // extraction process (ng xi18n) relies on a raw content to generate |
| // message ids |
| rootNodes = |
| visitAll$1(new I18nMetaVisitor(interpolationConfig, !preserveWhitespaces), rootNodes); |
| if (!preserveWhitespaces) { |
| rootNodes = visitAll$1(new WhitespaceVisitor(), rootNodes); |
| // run i18n meta visitor again in case we remove whitespaces, because |
| // that might affect generated i18n message content. During this pass |
| // i18n IDs generated at the first pass will be preserved, so we can mimic |
| // existing extraction process (ng xi18n) |
| rootNodes = visitAll$1(new I18nMetaVisitor(interpolationConfig, /* keepI18nAttrs */ false), rootNodes); |
| } |
| var _a = htmlAstToRender3Ast(rootNodes, bindingParser), nodes = _a.nodes, errors = _a.errors, styleUrls = _a.styleUrls, styles = _a.styles; |
| if (errors && errors.length > 0) { |
| return { errors: errors, nodes: [], styleUrls: [], styles: [] }; |
| } |
| return { nodes: nodes, styleUrls: styleUrls, styles: styles }; |
| } |
| /** |
| * Construct a `BindingParser` with a default configuration. |
| */ |
| function makeBindingParser(interpolationConfig) { |
| if (interpolationConfig === void 0) { interpolationConfig = DEFAULT_INTERPOLATION_CONFIG; } |
| return new BindingParser(new Parser$1(new Lexer()), interpolationConfig, new DomElementSchemaRegistry(), null, []); |
| } |
| function resolveSanitizationFn(context, isAttribute) { |
| switch (context) { |
| case SecurityContext.HTML: |
| return importExpr(Identifiers$1.sanitizeHtml); |
| case SecurityContext.SCRIPT: |
| return importExpr(Identifiers$1.sanitizeScript); |
| case SecurityContext.STYLE: |
| // the compiler does not fill in an instruction for [style.prop?] binding |
| // values because the style algorithm knows internally what props are subject |
| // to sanitization (only [attr.style] values are explicitly sanitized) |
| return isAttribute ? importExpr(Identifiers$1.sanitizeStyle) : null; |
| case SecurityContext.URL: |
| return importExpr(Identifiers$1.sanitizeUrl); |
| case SecurityContext.RESOURCE_URL: |
| return importExpr(Identifiers$1.sanitizeResourceUrl); |
| default: |
| return null; |
| } |
| } |
| function isSingleElementTemplate(children) { |
| return children.length === 1 && children[0] instanceof Element; |
| } |
| function isTextNode(node) { |
| return node instanceof Text || node instanceof BoundText || node instanceof Icu; |
| } |
| function hasTextChildrenOnly(children) { |
| return children.every(isTextNode); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var EMPTY_ARRAY = []; |
| // This regex matches any binding names that contain the "attr." prefix, e.g. "attr.required" |
| // If there is a match, the first matching group will contain the attribute name to bind. |
| var ATTR_REGEX = /attr\.([^\]]+)/; |
| function getStylingPrefix(name) { |
| return name.substring(0, 5); // style or class |
| } |
| function baseDirectiveFields(meta, constantPool, bindingParser) { |
| var definitionMap = new DefinitionMap(); |
| // e.g. `type: MyDirective` |
| definitionMap.set('type', meta.type); |
| // e.g. `selectors: [['', 'someDir', '']]` |
| definitionMap.set('selectors', createDirectiveSelector(meta.selector)); |
| // e.g. `factory: () => new MyApp(directiveInject(ElementRef))` |
| var result = compileFactoryFunction({ |
| name: meta.name, |
| type: meta.type, |
| deps: meta.deps, |
| injectFn: Identifiers$1.directiveInject, |
| }); |
| definitionMap.set('factory', result.factory); |
| if (meta.queries.length > 0) { |
| // e.g. `contentQueries: (rf, ctx, dirIndex) => { ... } |
| definitionMap.set('contentQueries', createContentQueriesFunction(meta.queries, constantPool, meta.name)); |
| } |
| if (meta.viewQueries.length) { |
| definitionMap.set('viewQuery', createViewQueriesFunction(meta.viewQueries, constantPool, meta.name)); |
| } |
| // e.g. `hostBindings: (rf, ctx, elIndex) => { ... } |
| definitionMap.set('hostBindings', createHostBindingsFunction(meta.host, meta.typeSourceSpan, bindingParser, constantPool, meta.selector || '', meta.name)); |
| // e.g 'inputs: {a: 'a'}` |
| definitionMap.set('inputs', conditionallyCreateMapObjectLiteral(meta.inputs, true)); |
| // e.g 'outputs: {a: 'a'}` |
| definitionMap.set('outputs', conditionallyCreateMapObjectLiteral(meta.outputs)); |
| if (meta.exportAs !== null) { |
| definitionMap.set('exportAs', literalArr(meta.exportAs.map(function (e) { return literal(e); }))); |
| } |
| return { definitionMap: definitionMap, statements: result.statements }; |
| } |
| /** |
| * Add features to the definition map. |
| */ |
| function addFeatures(definitionMap, meta) { |
| // e.g. `features: [NgOnChangesFeature()]` |
| var features = []; |
| var providers = meta.providers; |
| var viewProviders = meta.viewProviders; |
| if (providers || viewProviders) { |
| var args = [providers || new LiteralArrayExpr([])]; |
| if (viewProviders) { |
| args.push(viewProviders); |
| } |
| features.push(importExpr(Identifiers$1.ProvidersFeature).callFn(args)); |
| } |
| if (meta.usesInheritance) { |
| features.push(importExpr(Identifiers$1.InheritDefinitionFeature)); |
| } |
| if (meta.lifecycle.usesOnChanges) { |
| features.push(importExpr(Identifiers$1.NgOnChangesFeature).callFn(EMPTY_ARRAY)); |
| } |
| if (features.length) { |
| definitionMap.set('features', literalArr(features)); |
| } |
| } |
| /** |
| * Compile a directive for the render3 runtime as defined by the `R3DirectiveMetadata`. |
| */ |
| function compileDirectiveFromMetadata(meta, constantPool, bindingParser) { |
| var _a = baseDirectiveFields(meta, constantPool, bindingParser), definitionMap = _a.definitionMap, statements = _a.statements; |
| addFeatures(definitionMap, meta); |
| var expression = importExpr(Identifiers$1.defineDirective).callFn([definitionMap.toLiteralMap()]); |
| if (!meta.selector) { |
| throw new Error("Directive " + meta.name + " has no selector, please add it!"); |
| } |
| var type = createTypeForDef(meta, Identifiers$1.DirectiveDefWithMeta); |
| return { expression: expression, type: type, statements: statements }; |
| } |
| /** |
| * Compile a base definition for the render3 runtime as defined by {@link R3BaseRefMetadata} |
| * @param meta the metadata used for compilation. |
| */ |
| function compileBaseDefFromMetadata(meta, constantPool, bindingParser) { |
| var definitionMap = new DefinitionMap(); |
| if (meta.inputs) { |
| var inputs_1 = meta.inputs; |
| var inputsMap = Object.keys(inputs_1).map(function (key) { |
| var v = inputs_1[key]; |
| var value = Array.isArray(v) ? literalArr(v.map(function (vx) { return literal(vx); })) : literal(v); |
| return { key: key, value: value, quoted: false }; |
| }); |
| definitionMap.set('inputs', literalMap(inputsMap)); |
| } |
| if (meta.outputs) { |
| var outputs_1 = meta.outputs; |
| var outputsMap = Object.keys(outputs_1).map(function (key) { |
| var value = literal(outputs_1[key]); |
| return { key: key, value: value, quoted: false }; |
| }); |
| definitionMap.set('outputs', literalMap(outputsMap)); |
| } |
| if (meta.viewQueries && meta.viewQueries.length > 0) { |
| definitionMap.set('viewQuery', createViewQueriesFunction(meta.viewQueries, constantPool)); |
| } |
| if (meta.queries && meta.queries.length > 0) { |
| definitionMap.set('contentQueries', createContentQueriesFunction(meta.queries, constantPool)); |
| } |
| if (meta.host) { |
| definitionMap.set('hostBindings', createHostBindingsFunction(meta.host, meta.typeSourceSpan, bindingParser, constantPool, meta.name)); |
| } |
| var expression = importExpr(Identifiers$1.defineBase).callFn([definitionMap.toLiteralMap()]); |
| var type = new ExpressionType(importExpr(Identifiers$1.BaseDef)); |
| return { expression: expression, type: type }; |
| } |
| /** |
| * Compile a component for the render3 runtime as defined by the `R3ComponentMetadata`. |
| */ |
| function compileComponentFromMetadata(meta, constantPool, bindingParser) { |
| var e_1, _a; |
| var _b = baseDirectiveFields(meta, constantPool, bindingParser), definitionMap = _b.definitionMap, statements = _b.statements; |
| addFeatures(definitionMap, meta); |
| var selector = meta.selector && CssSelector.parse(meta.selector); |
| var firstSelector = selector && selector[0]; |
| // e.g. `attr: ["class", ".my.app"]` |
| // This is optional an only included if the first selector of a component specifies attributes. |
| if (firstSelector) { |
| var selectorAttributes = firstSelector.getAttrs(); |
| if (selectorAttributes.length) { |
| definitionMap.set('attrs', constantPool.getConstLiteral(literalArr(selectorAttributes.map(function (value) { return value != null ? literal(value) : literal(undefined); })), |
| /* forceShared */ true)); |
| } |
| } |
| // Generate the CSS matcher that recognize directive |
| var directiveMatcher = null; |
| if (meta.directives.length > 0) { |
| var matcher = new SelectorMatcher(); |
| try { |
| for (var _c = __values(meta.directives), _d = _c.next(); !_d.done; _d = _c.next()) { |
| var _e = _d.value, selector_1 = _e.selector, expression_1 = _e.expression; |
| matcher.addSelectables(CssSelector.parse(selector_1), expression_1); |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (_d && !_d.done && (_a = _c.return)) _a.call(_c); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| directiveMatcher = matcher; |
| } |
| // e.g. `template: function MyComponent_Template(_ctx, _cm) {...}` |
| var templateTypeName = meta.name; |
| var templateName = templateTypeName ? templateTypeName + "_Template" : null; |
| var directivesUsed = new Set(); |
| var pipesUsed = new Set(); |
| var changeDetection = meta.changeDetection; |
| var template = meta.template; |
| var templateBuilder = new TemplateDefinitionBuilder(constantPool, BindingScope.ROOT_SCOPE, 0, templateTypeName, null, null, templateName, directiveMatcher, directivesUsed, meta.pipes, pipesUsed, Identifiers$1.namespaceHTML, meta.relativeContextFilePath, meta.i18nUseExternalIds); |
| var templateFunctionExpression = templateBuilder.buildTemplateFunction(template.nodes, []); |
| // We need to provide this so that dynamically generated components know what |
| // projected content blocks to pass through to the component when it is instantiated. |
| var ngContentSelectors = templateBuilder.getNgContentSelectors(); |
| if (ngContentSelectors) { |
| definitionMap.set('ngContentSelectors', ngContentSelectors); |
| } |
| // e.g. `consts: 2` |
| definitionMap.set('consts', literal(templateBuilder.getConstCount())); |
| // e.g. `vars: 2` |
| definitionMap.set('vars', literal(templateBuilder.getVarCount())); |
| definitionMap.set('template', templateFunctionExpression); |
| // e.g. `directives: [MyDirective]` |
| if (directivesUsed.size) { |
| var directivesExpr = literalArr(Array.from(directivesUsed)); |
| if (meta.wrapDirectivesAndPipesInClosure) { |
| directivesExpr = fn([], [new ReturnStatement(directivesExpr)]); |
| } |
| definitionMap.set('directives', directivesExpr); |
| } |
| // e.g. `pipes: [MyPipe]` |
| if (pipesUsed.size) { |
| var pipesExpr = literalArr(Array.from(pipesUsed)); |
| if (meta.wrapDirectivesAndPipesInClosure) { |
| pipesExpr = fn([], [new ReturnStatement(pipesExpr)]); |
| } |
| definitionMap.set('pipes', pipesExpr); |
| } |
| if (meta.encapsulation === null) { |
| meta.encapsulation = ViewEncapsulation.Emulated; |
| } |
| // e.g. `styles: [str1, str2]` |
| if (meta.styles && meta.styles.length) { |
| var styleValues = meta.encapsulation == ViewEncapsulation.Emulated ? |
| compileStyles(meta.styles, CONTENT_ATTR, HOST_ATTR) : |
| meta.styles; |
| var strings = styleValues.map(function (str) { return literal(str); }); |
| definitionMap.set('styles', literalArr(strings)); |
| } |
| else if (meta.encapsulation === ViewEncapsulation.Emulated) { |
| // If there is no style, don't generate css selectors on elements |
| meta.encapsulation = ViewEncapsulation.None; |
| } |
| // Only set view encapsulation if it's not the default value |
| if (meta.encapsulation !== ViewEncapsulation.Emulated) { |
| definitionMap.set('encapsulation', literal(meta.encapsulation)); |
| } |
| // e.g. `animation: [trigger('123', [])]` |
| if (meta.animations !== null) { |
| definitionMap.set('data', literalMap([{ key: 'animation', value: meta.animations, quoted: false }])); |
| } |
| // Only set the change detection flag if it's defined and it's not the default. |
| if (changeDetection != null && changeDetection !== ChangeDetectionStrategy.Default) { |
| definitionMap.set('changeDetection', literal(changeDetection)); |
| } |
| // On the type side, remove newlines from the selector as it will need to fit into a TypeScript |
| // string literal, which must be on one line. |
| var selectorForType = (meta.selector || '').replace(/\n/g, ''); |
| var expression = importExpr(Identifiers$1.defineComponent).callFn([definitionMap.toLiteralMap()]); |
| var type = createTypeForDef(meta, Identifiers$1.ComponentDefWithMeta); |
| return { expression: expression, type: type, statements: statements }; |
| } |
| /** |
| * A wrapper around `compileDirective` which depends on render2 global analysis data as its input |
| * instead of the `R3DirectiveMetadata`. |
| * |
| * `R3DirectiveMetadata` is computed from `CompileDirectiveMetadata` and other statically reflected |
| * information. |
| */ |
| function compileDirectiveFromRender2(outputCtx, directive, reflector, bindingParser) { |
| var name = identifierName(directive.type); |
| name || error("Cannot resolver the name of " + directive.type); |
| var definitionField = outputCtx.constantPool.propertyNameOf(1 /* Directive */); |
| var meta = directiveMetadataFromGlobalMetadata(directive, outputCtx, reflector); |
| var res = compileDirectiveFromMetadata(meta, outputCtx.constantPool, bindingParser); |
| // Create the partial class to be merged with the actual class. |
| outputCtx.statements.push(new ClassStmt(name, null, [new ClassField(definitionField, INFERRED_TYPE, [exports.StmtModifier.Static], res.expression)], [], new ClassMethod(null, [], []), [])); |
| } |
| /** |
| * A wrapper around `compileComponent` which depends on render2 global analysis data as its input |
| * instead of the `R3DirectiveMetadata`. |
| * |
| * `R3ComponentMetadata` is computed from `CompileDirectiveMetadata` and other statically reflected |
| * information. |
| */ |
| function compileComponentFromRender2(outputCtx, component, render3Ast, reflector, bindingParser, directiveTypeBySel, pipeTypeByName) { |
| var name = identifierName(component.type); |
| name || error("Cannot resolver the name of " + component.type); |
| var definitionField = outputCtx.constantPool.propertyNameOf(2 /* Component */); |
| var summary = component.toSummary(); |
| // Compute the R3ComponentMetadata from the CompileDirectiveMetadata |
| var meta = __assign({}, directiveMetadataFromGlobalMetadata(component, outputCtx, reflector), { selector: component.selector, template: { nodes: render3Ast.nodes }, directives: [], pipes: typeMapToExpressionMap(pipeTypeByName, outputCtx), viewQueries: queriesFromGlobalMetadata(component.viewQueries, outputCtx), wrapDirectivesAndPipesInClosure: false, styles: (summary.template && summary.template.styles) || EMPTY_ARRAY, encapsulation: (summary.template && summary.template.encapsulation) || ViewEncapsulation.Emulated, interpolation: DEFAULT_INTERPOLATION_CONFIG, animations: null, viewProviders: component.viewProviders.length > 0 ? new WrappedNodeExpr(component.viewProviders) : null, relativeContextFilePath: '', i18nUseExternalIds: true }); |
| var res = compileComponentFromMetadata(meta, outputCtx.constantPool, bindingParser); |
| // Create the partial class to be merged with the actual class. |
| outputCtx.statements.push(new ClassStmt(name, null, [new ClassField(definitionField, INFERRED_TYPE, [exports.StmtModifier.Static], res.expression)], [], new ClassMethod(null, [], []), [])); |
| } |
| /** |
| * Compute `R3DirectiveMetadata` given `CompileDirectiveMetadata` and a `CompileReflector`. |
| */ |
| function directiveMetadataFromGlobalMetadata(directive, outputCtx, reflector) { |
| // The global-analysis based Ivy mode in ngc is no longer utilized/supported. |
| throw new Error('unsupported'); |
| } |
| /** |
| * Convert `CompileQueryMetadata` into `R3QueryMetadata`. |
| */ |
| function queriesFromGlobalMetadata(queries, outputCtx) { |
| return queries.map(function (query) { |
| var read = null; |
| if (query.read && query.read.identifier) { |
| read = outputCtx.importExpr(query.read.identifier.reference); |
| } |
| return { |
| propertyName: query.propertyName, |
| first: query.first, |
| predicate: selectorsFromGlobalMetadata(query.selectors, outputCtx), |
| descendants: query.descendants, read: read, |
| static: !!query.static |
| }; |
| }); |
| } |
| /** |
| * Convert `CompileTokenMetadata` for query selectors into either an expression for a predicate |
| * type, or a list of string predicates. |
| */ |
| function selectorsFromGlobalMetadata(selectors, outputCtx) { |
| if (selectors.length > 1 || (selectors.length == 1 && selectors[0].value)) { |
| var selectorStrings = selectors.map(function (value) { return value.value; }); |
| selectorStrings.some(function (value) { return !value; }) && |
| error('Found a type among the string selectors expected'); |
| return outputCtx.constantPool.getConstLiteral(literalArr(selectorStrings.map(function (value) { return literal(value); }))); |
| } |
| if (selectors.length == 1) { |
| var first = selectors[0]; |
| if (first.identifier) { |
| return outputCtx.importExpr(first.identifier.reference); |
| } |
| } |
| error('Unexpected query form'); |
| return NULL_EXPR; |
| } |
| function prepareQueryParams(query, constantPool) { |
| var parameters = [ |
| getQueryPredicate(query, constantPool), |
| literal(query.descendants), |
| query.read || literal(null), |
| ]; |
| return parameters; |
| } |
| // Turn a directive selector into an R3-compatible selector for directive def |
| function createDirectiveSelector(selector) { |
| return asLiteral(parseSelectorToR3Selector(selector)); |
| } |
| function convertAttributesToExpressions(attributes) { |
| var e_2, _a; |
| var values = []; |
| try { |
| for (var _b = __values(Object.getOwnPropertyNames(attributes)), _c = _b.next(); !_c.done; _c = _b.next()) { |
| var key = _c.value; |
| var value = attributes[key]; |
| values.push(literal(key), value); |
| } |
| } |
| catch (e_2_1) { e_2 = { error: e_2_1 }; } |
| finally { |
| try { |
| if (_c && !_c.done && (_a = _b.return)) _a.call(_b); |
| } |
| finally { if (e_2) throw e_2.error; } |
| } |
| return values; |
| } |
| // Define and update any content queries |
| function createContentQueriesFunction(queries, constantPool, name) { |
| var e_3, _a; |
| var createStatements = []; |
| var updateStatements = []; |
| var tempAllocator = temporaryAllocator(updateStatements, TEMPORARY_NAME); |
| try { |
| for (var queries_1 = __values(queries), queries_1_1 = queries_1.next(); !queries_1_1.done; queries_1_1 = queries_1.next()) { |
| var query = queries_1_1.value; |
| // creation, e.g. r3.contentQuery(dirIndex, somePredicate, true, null); |
| var args = __spread([variable('dirIndex')], prepareQueryParams(query, constantPool)); |
| var queryInstruction = query.static ? Identifiers$1.staticContentQuery : Identifiers$1.contentQuery; |
| createStatements.push(importExpr(queryInstruction).callFn(args).toStmt()); |
| // update, e.g. (r3.queryRefresh(tmp = r3.loadContentQuery()) && (ctx.someDir = tmp)); |
| var temporary = tempAllocator(); |
| var getQueryList = importExpr(Identifiers$1.loadContentQuery).callFn([]); |
| var refresh = importExpr(Identifiers$1.queryRefresh).callFn([temporary.set(getQueryList)]); |
| var updateDirective = variable(CONTEXT_NAME) |
| .prop(query.propertyName) |
| .set(query.first ? temporary.prop('first') : temporary); |
| updateStatements.push(refresh.and(updateDirective).toStmt()); |
| } |
| } |
| catch (e_3_1) { e_3 = { error: e_3_1 }; } |
| finally { |
| try { |
| if (queries_1_1 && !queries_1_1.done && (_a = queries_1.return)) _a.call(queries_1); |
| } |
| finally { if (e_3) throw e_3.error; } |
| } |
| var contentQueriesFnName = name ? name + "_ContentQueries" : null; |
| return fn([ |
| new FnParam(RENDER_FLAGS, NUMBER_TYPE), new FnParam(CONTEXT_NAME, null), |
| new FnParam('dirIndex', null) |
| ], [ |
| renderFlagCheckIfStmt(1 /* Create */, createStatements), |
| renderFlagCheckIfStmt(2 /* Update */, updateStatements) |
| ], INFERRED_TYPE, null, contentQueriesFnName); |
| } |
| function stringAsType(str) { |
| return expressionType(literal(str)); |
| } |
| function stringMapAsType(map) { |
| var mapValues = Object.keys(map).map(function (key) { |
| var value = Array.isArray(map[key]) ? map[key][0] : map[key]; |
| return { |
| key: key, |
| value: literal(value), |
| quoted: true, |
| }; |
| }); |
| return expressionType(literalMap(mapValues)); |
| } |
| function stringArrayAsType(arr) { |
| return arr.length > 0 ? expressionType(literalArr(arr.map(function (value) { return literal(value); }))) : |
| NONE_TYPE; |
| } |
| function createTypeForDef(meta, typeBase) { |
| // On the type side, remove newlines from the selector as it will need to fit into a TypeScript |
| // string literal, which must be on one line. |
| var selectorForType = (meta.selector || '').replace(/\n/g, ''); |
| return expressionType(importExpr(typeBase, [ |
| typeWithParameters(meta.type, meta.typeArgumentCount), |
| stringAsType(selectorForType), |
| meta.exportAs !== null ? stringArrayAsType(meta.exportAs) : NONE_TYPE, |
| stringMapAsType(meta.inputs), |
| stringMapAsType(meta.outputs), |
| stringArrayAsType(meta.queries.map(function (q) { return q.propertyName; })), |
| ])); |
| } |
| // Define and update any view queries |
| function createViewQueriesFunction(viewQueries, constantPool, name) { |
| var createStatements = []; |
| var updateStatements = []; |
| var tempAllocator = temporaryAllocator(updateStatements, TEMPORARY_NAME); |
| viewQueries.forEach(function (query) { |
| var queryInstruction = query.static ? Identifiers$1.staticViewQuery : Identifiers$1.viewQuery; |
| // creation, e.g. r3.viewQuery(somePredicate, true); |
| var queryDefinition = importExpr(queryInstruction).callFn(prepareQueryParams(query, constantPool)); |
| createStatements.push(queryDefinition.toStmt()); |
| // update, e.g. (r3.queryRefresh(tmp = r3.loadViewQuery()) && (ctx.someDir = tmp)); |
| var temporary = tempAllocator(); |
| var getQueryList = importExpr(Identifiers$1.loadViewQuery).callFn([]); |
| var refresh = importExpr(Identifiers$1.queryRefresh).callFn([temporary.set(getQueryList)]); |
| var updateDirective = variable(CONTEXT_NAME) |
| .prop(query.propertyName) |
| .set(query.first ? temporary.prop('first') : temporary); |
| updateStatements.push(refresh.and(updateDirective).toStmt()); |
| }); |
| var viewQueryFnName = name ? name + "_Query" : null; |
| return fn([new FnParam(RENDER_FLAGS, NUMBER_TYPE), new FnParam(CONTEXT_NAME, null)], [ |
| renderFlagCheckIfStmt(1 /* Create */, createStatements), |
| renderFlagCheckIfStmt(2 /* Update */, updateStatements) |
| ], INFERRED_TYPE, null, viewQueryFnName); |
| } |
| // Return a host binding function or null if one is not necessary. |
| function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindingParser, constantPool, selector, name) { |
| // Initialize hostVarsCount to number of bound host properties (interpolations illegal), |
| // except 'style' and 'class' properties, since they should *not* allocate host var slots |
| var hostVarsCount = Object.keys(hostBindingsMetadata.properties) |
| .filter(function (name) { |
| var prefix = getStylingPrefix(name); |
| return prefix !== 'style' && prefix !== 'class'; |
| }) |
| .length; |
| var elVarExp = variable('elIndex'); |
| var bindingContext = variable(CONTEXT_NAME); |
| var styleBuilder = new StylingBuilder(elVarExp, bindingContext); |
| var _a = hostBindingsMetadata.specialAttributes, styleAttr = _a.styleAttr, classAttr = _a.classAttr; |
| if (styleAttr !== undefined) { |
| styleBuilder.registerStyleAttr(styleAttr); |
| } |
| if (classAttr !== undefined) { |
| styleBuilder.registerClassAttr(classAttr); |
| } |
| var createStatements = []; |
| var updateStatements = []; |
| var totalHostVarsCount = hostVarsCount; |
| var hostBindingSourceSpan = typeSourceSpan; |
| var directiveSummary = metadataAsSummary(hostBindingsMetadata); |
| var valueConverter; |
| var getValueConverter = function () { |
| if (!valueConverter) { |
| var hostVarsCountFn = function (numSlots) { |
| var originalVarsCount = totalHostVarsCount; |
| totalHostVarsCount += numSlots; |
| return originalVarsCount; |
| }; |
| valueConverter = new ValueConverter(constantPool, function () { return error('Unexpected node'); }, // new nodes are illegal here |
| hostVarsCountFn, function () { return error('Unexpected pipe'); }); // pipes are illegal here |
| } |
| return valueConverter; |
| }; |
| // Calculate host event bindings |
| var eventBindings = bindingParser.createDirectiveHostEventAsts(directiveSummary, hostBindingSourceSpan); |
| if (eventBindings && eventBindings.length) { |
| var listeners = createHostListeners(eventBindings, name); |
| createStatements.push.apply(createStatements, __spread(listeners)); |
| } |
| // Calculate the host property bindings |
| var bindings = bindingParser.createBoundHostProperties(directiveSummary, hostBindingSourceSpan); |
| (bindings || []).forEach(function (binding) { |
| var name = binding.name; |
| var stylingInputWasSet = styleBuilder.registerInputBasedOnName(name, binding.expression, binding.sourceSpan); |
| if (!stylingInputWasSet) { |
| // resolve literal arrays and literal objects |
| var value = binding.expression.visit(getValueConverter()); |
| var bindingExpr = bindingFn(bindingContext, value); |
| var _a = getBindingNameAndInstruction(binding), bindingName = _a.bindingName, instruction = _a.instruction, isAttribute = _a.isAttribute; |
| var securityContexts = bindingParser.calcPossibleSecurityContexts(selector, bindingName, isAttribute) |
| .filter(function (context) { return context !== SecurityContext.NONE; }); |
| var sanitizerFn = null; |
| if (securityContexts.length) { |
| if (securityContexts.length === 2 && |
| securityContexts.indexOf(SecurityContext.URL) > -1 && |
| securityContexts.indexOf(SecurityContext.RESOURCE_URL) > -1) { |
| // Special case for some URL attributes (such as "src" and "href") that may be a part |
| // of different security contexts. In this case we use special santitization function and |
| // select the actual sanitizer at runtime based on a tag name that is provided while |
| // invoking sanitization function. |
| sanitizerFn = importExpr(Identifiers$1.sanitizeUrlOrResourceUrl); |
| } |
| else { |
| sanitizerFn = resolveSanitizationFn(securityContexts[0], isAttribute); |
| } |
| } |
| var instructionParams = [literal(bindingName), bindingExpr.currValExpr]; |
| if (sanitizerFn) { |
| instructionParams.push(sanitizerFn); |
| } |
| if (!isAttribute) { |
| if (!sanitizerFn) { |
| // append `null` in front of `nativeOnly` flag if no sanitizer fn defined |
| instructionParams.push(literal(null)); |
| } |
| // host bindings must have nativeOnly prop set to true |
| instructionParams.push(literal(true)); |
| } |
| updateStatements.push.apply(updateStatements, __spread(bindingExpr.stmts)); |
| updateStatements.push(importExpr(instruction).callFn(instructionParams).toStmt()); |
| } |
| }); |
| // since we're dealing with directives/components and both have hostBinding |
| // functions, we need to generate a special hostAttrs instruction that deals |
| // with both the assignment of styling as well as static attributes to the host |
| // element. The instruction below will instruct all initial styling (styling |
| // that is inside of a host binding within a directive/component) to be attached |
| // to the host element alongside any of the provided host attributes that were |
| // collected earlier. |
| var hostAttrs = convertAttributesToExpressions(hostBindingsMetadata.attributes); |
| var hostInstruction = styleBuilder.buildHostAttrsInstruction(null, hostAttrs, constantPool); |
| if (hostInstruction) { |
| createStatements.push(createStylingStmt(hostInstruction, bindingContext, bindingFn)); |
| } |
| if (styleBuilder.hasBindings) { |
| // singular style/class bindings (things like `[style.prop]` and `[class.name]`) |
| // MUST be registered on a given element within the component/directive |
| // templateFn/hostBindingsFn functions. The instruction below will figure out |
| // what all the bindings are and then generate the statements required to register |
| // those bindings to the element via `styling`. |
| var stylingInstruction = styleBuilder.buildStylingInstruction(null, constantPool); |
| if (stylingInstruction) { |
| createStatements.push(createStylingStmt(stylingInstruction, bindingContext, bindingFn)); |
| } |
| // finally each binding that was registered in the statement above will need to be added to |
| // the update block of a component/directive templateFn/hostBindingsFn so that the bindings |
| // are evaluated and updated for the element. |
| styleBuilder.buildUpdateLevelInstructions(getValueConverter()).forEach(function (instruction) { |
| totalHostVarsCount += instruction.allocateBindingSlots; |
| updateStatements.push(createStylingStmt(instruction, bindingContext, bindingFn)); |
| }); |
| } |
| if (totalHostVarsCount) { |
| createStatements.unshift(importExpr(Identifiers$1.allocHostVars).callFn([literal(totalHostVarsCount)]).toStmt()); |
| } |
| if (createStatements.length > 0 || updateStatements.length > 0) { |
| var hostBindingsFnName = name ? name + "_HostBindings" : null; |
| var statements = []; |
| if (createStatements.length > 0) { |
| statements.push(renderFlagCheckIfStmt(1 /* Create */, createStatements)); |
| } |
| if (updateStatements.length > 0) { |
| statements.push(renderFlagCheckIfStmt(2 /* Update */, updateStatements)); |
| } |
| return fn([ |
| new FnParam(RENDER_FLAGS, NUMBER_TYPE), new FnParam(CONTEXT_NAME, null), |
| new FnParam(elVarExp.name, NUMBER_TYPE) |
| ], statements, INFERRED_TYPE, null, hostBindingsFnName); |
| } |
| return null; |
| } |
| function bindingFn(implicit, value) { |
| return convertPropertyBinding(null, implicit, value, 'b', BindingForm.TrySimple, function () { return error('Unexpected interpolation'); }); |
| } |
| function createStylingStmt(instruction, bindingContext, bindingFn) { |
| var params = instruction.buildParams(function (value) { return bindingFn(bindingContext, value).currValExpr; }); |
| return importExpr(instruction.reference, null, instruction.sourceSpan) |
| .callFn(params, instruction.sourceSpan) |
| .toStmt(); |
| } |
| function getBindingNameAndInstruction(binding) { |
| var bindingName = binding.name; |
| var instruction; |
| // Check to see if this is an attr binding or a property binding |
| var attrMatches = bindingName.match(ATTR_REGEX); |
| if (attrMatches) { |
| bindingName = attrMatches[1]; |
| instruction = Identifiers$1.attribute; |
| } |
| else { |
| if (binding.isAnimation) { |
| bindingName = prepareSyntheticPropertyName(bindingName); |
| // host bindings that have a synthetic property (e.g. @foo) should always be rendered |
| // in the context of the component and not the parent. Therefore there is a special |
| // compatibility instruction available for this purpose. |
| instruction = Identifiers$1.updateSyntheticHostBinding; |
| } |
| else { |
| instruction = Identifiers$1.property; |
| } |
| } |
| return { bindingName: bindingName, instruction: instruction, isAttribute: !!attrMatches }; |
| } |
| function createHostListeners(eventBindings, name) { |
| return eventBindings.map(function (binding) { |
| var bindingName = binding.name && sanitizeIdentifier(binding.name); |
| var bindingFnName = binding.type === 1 /* Animation */ ? |
| prepareSyntheticListenerFunctionName(bindingName, binding.targetOrPhase) : |
| bindingName; |
| var handlerName = name && bindingName ? name + "_" + bindingFnName + "_HostBindingHandler" : null; |
| var params = prepareEventListenerParameters(BoundEvent.fromParsedEvent(binding), handlerName); |
| var instruction = binding.type == 1 /* Animation */ ? Identifiers$1.componentHostSyntheticListener : Identifiers$1.listener; |
| return importExpr(instruction).callFn(params).toStmt(); |
| }); |
| } |
| function metadataAsSummary(meta) { |
| // clang-format off |
| return { |
| // This is used by the BindingParser, which only deals with listeners and properties. There's no |
| // need to pass attributes to it. |
| hostAttributes: {}, |
| hostListeners: meta.listeners, |
| hostProperties: meta.properties, |
| }; |
| // clang-format on |
| } |
| function typeMapToExpressionMap(map, outputCtx) { |
| // Convert each map entry into another entry where the value is an expression importing the type. |
| var entries = Array.from(map).map(function (_a) { |
| var _b = __read(_a, 2), key = _b[0], type = _b[1]; |
| return [key, outputCtx.importExpr(type)]; |
| }); |
| return new Map(entries); |
| } |
| var HOST_REG_EXP$1 = /^(?:\[([^\]]+)\])|(?:\(([^\)]+)\))$/; |
| function parseHostBindings(host) { |
| var e_4, _a; |
| var attributes = {}; |
| var listeners = {}; |
| var properties = {}; |
| var specialAttributes = {}; |
| try { |
| for (var _b = __values(Object.keys(host)), _c = _b.next(); !_c.done; _c = _b.next()) { |
| var key = _c.value; |
| var value = host[key]; |
| var matches = key.match(HOST_REG_EXP$1); |
| if (matches === null) { |
| switch (key) { |
| case 'class': |
| if (typeof value !== 'string') { |
| // TODO(alxhub): make this a diagnostic. |
| throw new Error("Class binding must be string"); |
| } |
| specialAttributes.classAttr = value; |
| break; |
| case 'style': |
| if (typeof value !== 'string') { |
| // TODO(alxhub): make this a diagnostic. |
| throw new Error("Style binding must be string"); |
| } |
| specialAttributes.styleAttr = value; |
| break; |
| default: |
| if (typeof value === 'string') { |
| attributes[key] = literal(value); |
| } |
| else { |
| attributes[key] = value; |
| } |
| } |
| } |
| else if (matches[1 /* Binding */] != null) { |
| if (typeof value !== 'string') { |
| // TODO(alxhub): make this a diagnostic. |
| throw new Error("Property binding must be string"); |
| } |
| // synthetic properties (the ones that have a `@` as a prefix) |
| // are still treated the same as regular properties. Therefore |
| // there is no point in storing them in a separate map. |
| properties[matches[1 /* Binding */]] = value; |
| } |
| else if (matches[2 /* Event */] != null) { |
| if (typeof value !== 'string') { |
| // TODO(alxhub): make this a diagnostic. |
| throw new Error("Event binding must be string"); |
| } |
| listeners[matches[2 /* Event */]] = value; |
| } |
| } |
| } |
| catch (e_4_1) { e_4 = { error: e_4_1 }; } |
| finally { |
| try { |
| if (_c && !_c.done && (_a = _b.return)) _a.call(_b); |
| } |
| finally { if (e_4) throw e_4.error; } |
| } |
| return { attributes: attributes, listeners: listeners, properties: properties, specialAttributes: specialAttributes }; |
| } |
| /** |
| * Verifies host bindings and returns the list of errors (if any). Empty array indicates that a |
| * given set of host bindings has no errors. |
| * |
| * @param bindings set of host bindings to verify. |
| * @param sourceSpan source span where host bindings were defined. |
| * @returns array of errors associated with a given set of host bindings. |
| */ |
| function verifyHostBindings(bindings, sourceSpan) { |
| var summary = metadataAsSummary(bindings); |
| // TODO: abstract out host bindings verification logic and use it instead of |
| // creating events and properties ASTs to detect errors (FW-996) |
| var bindingParser = makeBindingParser(); |
| bindingParser.createDirectiveHostEventAsts(summary, sourceSpan); |
| bindingParser.createBoundHostProperties(summary, sourceSpan); |
| return bindingParser.errors; |
| } |
| function compileStyles(styles, selector, hostSelector) { |
| var shadowCss = new ShadowCss(); |
| return styles.map(function (style) { return shadowCss.shimCssText(style, selector, hostSelector); }); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * An interface for retrieving documents by URL that the compiler uses |
| * to load templates. |
| */ |
| var ResourceLoader = /** @class */ (function () { |
| function ResourceLoader() { |
| } |
| ResourceLoader.prototype.get = function (url) { return ''; }; |
| return ResourceLoader; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var CompilerFacadeImpl = /** @class */ (function () { |
| function CompilerFacadeImpl(jitEvaluator) { |
| if (jitEvaluator === void 0) { jitEvaluator = new JitEvaluator(); } |
| this.jitEvaluator = jitEvaluator; |
| this.R3ResolvedDependencyType = exports.R3ResolvedDependencyType; |
| this.ResourceLoader = ResourceLoader; |
| this.elementSchemaRegistry = new DomElementSchemaRegistry(); |
| } |
| CompilerFacadeImpl.prototype.compilePipe = function (angularCoreEnv, sourceMapUrl, facade) { |
| var res = compilePipeFromMetadata({ |
| name: facade.name, |
| type: new WrappedNodeExpr(facade.type), |
| typeArgumentCount: facade.typeArgumentCount, |
| deps: convertR3DependencyMetadataArray(facade.deps), |
| pipeName: facade.pipeName, |
| pure: facade.pure, |
| }); |
| return this.jitExpression(res.expression, angularCoreEnv, sourceMapUrl, res.statements); |
| }; |
| CompilerFacadeImpl.prototype.compileInjectable = function (angularCoreEnv, sourceMapUrl, facade) { |
| var _a = compileInjectable({ |
| name: facade.name, |
| type: new WrappedNodeExpr(facade.type), |
| typeArgumentCount: facade.typeArgumentCount, |
| providedIn: computeProvidedIn(facade.providedIn), |
| useClass: wrapExpression(facade, USE_CLASS), |
| useFactory: wrapExpression(facade, USE_FACTORY), |
| useValue: wrapExpression(facade, USE_VALUE), |
| useExisting: wrapExpression(facade, USE_EXISTING), |
| ctorDeps: convertR3DependencyMetadataArray(facade.ctorDeps), |
| userDeps: convertR3DependencyMetadataArray(facade.userDeps) || undefined, |
| }), expression = _a.expression, statements = _a.statements; |
| return this.jitExpression(expression, angularCoreEnv, sourceMapUrl, statements); |
| }; |
| CompilerFacadeImpl.prototype.compileInjector = function (angularCoreEnv, sourceMapUrl, facade) { |
| var meta = { |
| name: facade.name, |
| type: new WrappedNodeExpr(facade.type), |
| deps: convertR3DependencyMetadataArray(facade.deps), |
| providers: new WrappedNodeExpr(facade.providers), |
| imports: facade.imports.map(function (i) { return new WrappedNodeExpr(i); }), |
| }; |
| var res = compileInjector(meta); |
| return this.jitExpression(res.expression, angularCoreEnv, sourceMapUrl, res.statements); |
| }; |
| CompilerFacadeImpl.prototype.compileNgModule = function (angularCoreEnv, sourceMapUrl, facade) { |
| var meta = { |
| type: new WrappedNodeExpr(facade.type), |
| bootstrap: facade.bootstrap.map(wrapReference), |
| declarations: facade.declarations.map(wrapReference), |
| imports: facade.imports.map(wrapReference), |
| exports: facade.exports.map(wrapReference), |
| emitInline: true, |
| containsForwardDecls: false, |
| schemas: facade.schemas ? facade.schemas.map(wrapReference) : null, |
| id: facade.id ? new WrappedNodeExpr(facade.id) : null, |
| }; |
| var res = compileNgModule(meta); |
| return this.jitExpression(res.expression, angularCoreEnv, sourceMapUrl, []); |
| }; |
| CompilerFacadeImpl.prototype.compileDirective = function (angularCoreEnv, sourceMapUrl, facade) { |
| var constantPool = new ConstantPool(); |
| var bindingParser = makeBindingParser(); |
| var meta = convertDirectiveFacadeToMetadata(facade); |
| var res = compileDirectiveFromMetadata(meta, constantPool, bindingParser); |
| var preStatements = __spread(constantPool.statements, res.statements); |
| return this.jitExpression(res.expression, angularCoreEnv, sourceMapUrl, preStatements); |
| }; |
| CompilerFacadeImpl.prototype.compileComponent = function (angularCoreEnv, sourceMapUrl, facade) { |
| // The ConstantPool is a requirement of the JIT'er. |
| var constantPool = new ConstantPool(); |
| var interpolationConfig = facade.interpolation ? |
| InterpolationConfig.fromArray(facade.interpolation) : |
| DEFAULT_INTERPOLATION_CONFIG; |
| // Parse the template and check for errors. |
| var template = parseTemplate(facade.template, sourceMapUrl, { preserveWhitespaces: facade.preserveWhitespaces, interpolationConfig: interpolationConfig }); |
| if (template.errors !== undefined) { |
| var errors = template.errors.map(function (err) { return err.toString(); }).join(', '); |
| throw new Error("Errors during JIT compilation of template for " + facade.name + ": " + errors); |
| } |
| // Compile the component metadata, including template, into an expression. |
| // TODO(alxhub): implement inputs, outputs, queries, etc. |
| var res = compileComponentFromMetadata(__assign({}, facade, convertDirectiveFacadeToMetadata(facade), { selector: facade.selector || this.elementSchemaRegistry.getDefaultComponentElementName(), template: template, wrapDirectivesAndPipesInClosure: false, styles: facade.styles || [], encapsulation: facade.encapsulation, interpolation: interpolationConfig, changeDetection: facade.changeDetection, animations: facade.animations != null ? new WrappedNodeExpr(facade.animations) : null, viewProviders: facade.viewProviders != null ? new WrappedNodeExpr(facade.viewProviders) : |
| null, relativeContextFilePath: '', i18nUseExternalIds: true }), constantPool, makeBindingParser(interpolationConfig)); |
| var preStatements = __spread(constantPool.statements, res.statements); |
| return this.jitExpression(res.expression, angularCoreEnv, "ng:///" + facade.name + ".js", preStatements); |
| }; |
| CompilerFacadeImpl.prototype.compileBase = function (angularCoreEnv, sourceMapUrl, facade) { |
| var constantPool = new ConstantPool(); |
| var typeSourceSpan = this.createParseSourceSpan('Base', facade.name, "ng:///" + facade.name + ".js"); |
| var meta = __assign({}, facade, { typeSourceSpan: typeSourceSpan, viewQueries: facade.viewQueries ? facade.viewQueries.map(convertToR3QueryMetadata) : |
| facade.viewQueries, queries: facade.queries ? facade.queries.map(convertToR3QueryMetadata) : facade.queries, host: extractHostBindings(facade.propMetadata, typeSourceSpan) }); |
| var res = compileBaseDefFromMetadata(meta, constantPool, makeBindingParser()); |
| return this.jitExpression(res.expression, angularCoreEnv, sourceMapUrl, constantPool.statements); |
| }; |
| CompilerFacadeImpl.prototype.createParseSourceSpan = function (kind, typeName, sourceUrl) { |
| return r3JitTypeSourceSpan(kind, typeName, sourceUrl); |
| }; |
| /** |
| * JIT compiles an expression and returns the result of executing that expression. |
| * |
| * @param def the definition which will be compiled and executed to get the value to patch |
| * @param context an object map of @angular/core symbol names to symbols which will be available |
| * in the context of the compiled expression |
| * @param sourceUrl a URL to use for the source map of the compiled expression |
| * @param preStatements a collection of statements that should be evaluated before the expression. |
| */ |
| CompilerFacadeImpl.prototype.jitExpression = function (def, context, sourceUrl, preStatements) { |
| // The ConstantPool may contain Statements which declare variables used in the final expression. |
| // Therefore, its statements need to precede the actual JIT operation. The final statement is a |
| // declaration of $def which is set to the expression being compiled. |
| var statements = __spread(preStatements, [ |
| new DeclareVarStmt('$def', def, undefined, [exports.StmtModifier.Exported]), |
| ]); |
| var res = this.jitEvaluator.evaluateStatements(sourceUrl, statements, new R3JitReflector(context), /* enableSourceMaps */ true); |
| return res['$def']; |
| }; |
| return CompilerFacadeImpl; |
| }()); |
| var USE_CLASS = Object.keys({ useClass: null })[0]; |
| var USE_FACTORY = Object.keys({ useFactory: null })[0]; |
| var USE_VALUE = Object.keys({ useValue: null })[0]; |
| var USE_EXISTING = Object.keys({ useExisting: null })[0]; |
| var wrapReference = function (value) { |
| var wrapped = new WrappedNodeExpr(value); |
| return { value: wrapped, type: wrapped }; |
| }; |
| function convertToR3QueryMetadata(facade) { |
| return __assign({}, facade, { predicate: Array.isArray(facade.predicate) ? facade.predicate : |
| new WrappedNodeExpr(facade.predicate), read: facade.read ? new WrappedNodeExpr(facade.read) : null, static: facade.static }); |
| } |
| function convertDirectiveFacadeToMetadata(facade) { |
| var inputsFromMetadata = parseInputOutputs(facade.inputs || []); |
| var outputsFromMetadata = parseInputOutputs(facade.outputs || []); |
| var propMetadata = facade.propMetadata; |
| var inputsFromType = {}; |
| var outputsFromType = {}; |
| var _loop_1 = function (field) { |
| if (propMetadata.hasOwnProperty(field)) { |
| propMetadata[field].forEach(function (ann) { |
| if (isInput(ann)) { |
| inputsFromType[field] = |
| ann.bindingPropertyName ? [ann.bindingPropertyName, field] : field; |
| } |
| else if (isOutput(ann)) { |
| outputsFromType[field] = ann.bindingPropertyName || field; |
| } |
| }); |
| } |
| }; |
| for (var field in propMetadata) { |
| _loop_1(field); |
| } |
| return __assign({}, facade, { typeSourceSpan: facade.typeSourceSpan, type: new WrappedNodeExpr(facade.type), deps: convertR3DependencyMetadataArray(facade.deps), host: extractHostBindings(facade.propMetadata, facade.typeSourceSpan, facade.host), inputs: __assign({}, inputsFromMetadata, inputsFromType), outputs: __assign({}, outputsFromMetadata, outputsFromType), queries: facade.queries.map(convertToR3QueryMetadata), providers: facade.providers != null ? new WrappedNodeExpr(facade.providers) : null, viewQueries: facade.viewQueries.map(convertToR3QueryMetadata) }); |
| } |
| function wrapExpression(obj, property) { |
| if (obj.hasOwnProperty(property)) { |
| return new WrappedNodeExpr(obj[property]); |
| } |
| else { |
| return undefined; |
| } |
| } |
| function computeProvidedIn(providedIn) { |
| if (providedIn == null || typeof providedIn === 'string') { |
| return new LiteralExpr(providedIn); |
| } |
| else { |
| return new WrappedNodeExpr(providedIn); |
| } |
| } |
| function convertR3DependencyMetadata(facade) { |
| var tokenExpr; |
| if (facade.token === null) { |
| tokenExpr = new LiteralExpr(null); |
| } |
| else if (facade.resolved === exports.R3ResolvedDependencyType.Attribute) { |
| tokenExpr = new LiteralExpr(facade.token); |
| } |
| else { |
| tokenExpr = new WrappedNodeExpr(facade.token); |
| } |
| return { |
| token: tokenExpr, |
| resolved: facade.resolved, |
| host: facade.host, |
| optional: facade.optional, |
| self: facade.self, |
| skipSelf: facade.skipSelf |
| }; |
| } |
| function convertR3DependencyMetadataArray(facades) { |
| return facades == null ? null : facades.map(convertR3DependencyMetadata); |
| } |
| function extractHostBindings(propMetadata, sourceSpan, host) { |
| // First parse the declarations from the metadata. |
| var bindings = parseHostBindings(host || {}); |
| // After that check host bindings for errors |
| var errors = verifyHostBindings(bindings, sourceSpan); |
| if (errors.length) { |
| throw new Error(errors.map(function (error) { return error.msg; }).join('\n')); |
| } |
| var _loop_2 = function (field) { |
| if (propMetadata.hasOwnProperty(field)) { |
| propMetadata[field].forEach(function (ann) { |
| if (isHostBinding(ann)) { |
| bindings.properties[ann.hostPropertyName || field] = field; |
| } |
| else if (isHostListener(ann)) { |
| bindings.listeners[ann.eventName || field] = field + "(" + (ann.args || []).join(',') + ")"; |
| } |
| }); |
| } |
| }; |
| // Next, loop over the properties of the object, looking for @HostBinding and @HostListener. |
| for (var field in propMetadata) { |
| _loop_2(field); |
| } |
| return bindings; |
| } |
| function isHostBinding(value) { |
| return value.ngMetadataName === 'HostBinding'; |
| } |
| function isHostListener(value) { |
| return value.ngMetadataName === 'HostListener'; |
| } |
| function isInput(value) { |
| return value.ngMetadataName === 'Input'; |
| } |
| function isOutput(value) { |
| return value.ngMetadataName === 'Output'; |
| } |
| function parseInputOutputs(values) { |
| return values.reduce(function (map, value) { |
| var _a = __read(value.split(',').map(function (piece) { return piece.trim(); }), 2), field = _a[0], property = _a[1]; |
| map[field] = property || field; |
| return map; |
| }, {}); |
| } |
| function publishFacade(global) { |
| var ng = global.ng || (global.ng = {}); |
| ng.ɵcompilerFacade = new CompilerFacadeImpl(); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var VERSION$1 = new Version('8.1.1'); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var CompilerConfig = /** @class */ (function () { |
| function CompilerConfig(_a) { |
| var _b = _a === void 0 ? {} : _a, _c = _b.defaultEncapsulation, defaultEncapsulation = _c === void 0 ? ViewEncapsulation.Emulated : _c, _d = _b.useJit, useJit = _d === void 0 ? true : _d, _e = _b.jitDevMode, jitDevMode = _e === void 0 ? false : _e, _f = _b.missingTranslation, missingTranslation = _f === void 0 ? null : _f, preserveWhitespaces = _b.preserveWhitespaces, strictInjectionParameters = _b.strictInjectionParameters; |
| this.defaultEncapsulation = defaultEncapsulation; |
| this.useJit = !!useJit; |
| this.jitDevMode = !!jitDevMode; |
| this.missingTranslation = missingTranslation; |
| this.preserveWhitespaces = preserveWhitespacesDefault(noUndefined(preserveWhitespaces)); |
| this.strictInjectionParameters = strictInjectionParameters === true; |
| } |
| return CompilerConfig; |
| }()); |
| function preserveWhitespacesDefault(preserveWhitespacesOption, defaultSetting) { |
| if (defaultSetting === void 0) { defaultSetting = false; } |
| return preserveWhitespacesOption === null ? defaultSetting : preserveWhitespacesOption; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var DirectiveNormalizer = /** @class */ (function () { |
| function DirectiveNormalizer(_resourceLoader, _urlResolver, _htmlParser, _config) { |
| this._resourceLoader = _resourceLoader; |
| this._urlResolver = _urlResolver; |
| this._htmlParser = _htmlParser; |
| this._config = _config; |
| this._resourceLoaderCache = new Map(); |
| } |
| DirectiveNormalizer.prototype.clearCache = function () { this._resourceLoaderCache.clear(); }; |
| DirectiveNormalizer.prototype.clearCacheFor = function (normalizedDirective) { |
| var _this = this; |
| if (!normalizedDirective.isComponent) { |
| return; |
| } |
| var template = normalizedDirective.template; |
| this._resourceLoaderCache.delete(template.templateUrl); |
| template.externalStylesheets.forEach(function (stylesheet) { _this._resourceLoaderCache.delete(stylesheet.moduleUrl); }); |
| }; |
| DirectiveNormalizer.prototype._fetch = function (url) { |
| var result = this._resourceLoaderCache.get(url); |
| if (!result) { |
| result = this._resourceLoader.get(url); |
| this._resourceLoaderCache.set(url, result); |
| } |
| return result; |
| }; |
| DirectiveNormalizer.prototype.normalizeTemplate = function (prenormData) { |
| var _this = this; |
| if (isDefined(prenormData.template)) { |
| if (isDefined(prenormData.templateUrl)) { |
| throw syntaxError("'" + stringify(prenormData.componentType) + "' component cannot define both template and templateUrl"); |
| } |
| if (typeof prenormData.template !== 'string') { |
| throw syntaxError("The template specified for component " + stringify(prenormData.componentType) + " is not a string"); |
| } |
| } |
| else if (isDefined(prenormData.templateUrl)) { |
| if (typeof prenormData.templateUrl !== 'string') { |
| throw syntaxError("The templateUrl specified for component " + stringify(prenormData.componentType) + " is not a string"); |
| } |
| } |
| else { |
| throw syntaxError("No template specified for component " + stringify(prenormData.componentType)); |
| } |
| if (isDefined(prenormData.preserveWhitespaces) && |
| typeof prenormData.preserveWhitespaces !== 'boolean') { |
| throw syntaxError("The preserveWhitespaces option for component " + stringify(prenormData.componentType) + " must be a boolean"); |
| } |
| return SyncAsync.then(this._preParseTemplate(prenormData), function (preparsedTemplate) { return _this._normalizeTemplateMetadata(prenormData, preparsedTemplate); }); |
| }; |
| DirectiveNormalizer.prototype._preParseTemplate = function (prenomData) { |
| var _this = this; |
| var template; |
| var templateUrl; |
| if (prenomData.template != null) { |
| template = prenomData.template; |
| templateUrl = prenomData.moduleUrl; |
| } |
| else { |
| templateUrl = this._urlResolver.resolve(prenomData.moduleUrl, prenomData.templateUrl); |
| template = this._fetch(templateUrl); |
| } |
| return SyncAsync.then(template, function (template) { return _this._preparseLoadedTemplate(prenomData, template, templateUrl); }); |
| }; |
| DirectiveNormalizer.prototype._preparseLoadedTemplate = function (prenormData, template, templateAbsUrl) { |
| var isInline = !!prenormData.template; |
| var interpolationConfig = InterpolationConfig.fromArray(prenormData.interpolation); |
| var templateUrl = templateSourceUrl({ reference: prenormData.ngModuleType }, { type: { reference: prenormData.componentType } }, { isInline: isInline, templateUrl: templateAbsUrl }); |
| var rootNodesAndErrors = this._htmlParser.parse(template, templateUrl, { tokenizeExpansionForms: true, interpolationConfig: interpolationConfig }); |
| if (rootNodesAndErrors.errors.length > 0) { |
| var errorString = rootNodesAndErrors.errors.join('\n'); |
| throw syntaxError("Template parse errors:\n" + errorString); |
| } |
| var templateMetadataStyles = this._normalizeStylesheet(new CompileStylesheetMetadata({ styles: prenormData.styles, moduleUrl: prenormData.moduleUrl })); |
| var visitor = new TemplatePreparseVisitor(); |
| visitAll$1(visitor, rootNodesAndErrors.rootNodes); |
| var templateStyles = this._normalizeStylesheet(new CompileStylesheetMetadata({ styles: visitor.styles, styleUrls: visitor.styleUrls, moduleUrl: templateAbsUrl })); |
| var styles = templateMetadataStyles.styles.concat(templateStyles.styles); |
| var inlineStyleUrls = templateMetadataStyles.styleUrls.concat(templateStyles.styleUrls); |
| var styleUrls = this |
| ._normalizeStylesheet(new CompileStylesheetMetadata({ styleUrls: prenormData.styleUrls, moduleUrl: prenormData.moduleUrl })) |
| .styleUrls; |
| return { |
| template: template, |
| templateUrl: templateAbsUrl, isInline: isInline, |
| htmlAst: rootNodesAndErrors, styles: styles, inlineStyleUrls: inlineStyleUrls, styleUrls: styleUrls, |
| ngContentSelectors: visitor.ngContentSelectors, |
| }; |
| }; |
| DirectiveNormalizer.prototype._normalizeTemplateMetadata = function (prenormData, preparsedTemplate) { |
| var _this = this; |
| return SyncAsync.then(this._loadMissingExternalStylesheets(preparsedTemplate.styleUrls.concat(preparsedTemplate.inlineStyleUrls)), function (externalStylesheets) { return _this._normalizeLoadedTemplateMetadata(prenormData, preparsedTemplate, externalStylesheets); }); |
| }; |
| DirectiveNormalizer.prototype._normalizeLoadedTemplateMetadata = function (prenormData, preparsedTemplate, stylesheets) { |
| // Algorithm: |
| // - produce exactly 1 entry per original styleUrl in |
| // CompileTemplateMetadata.externalStylesheets with all styles inlined |
| // - inline all styles that are referenced by the template into CompileTemplateMetadata.styles. |
| // Reason: be able to determine how many stylesheets there are even without loading |
| // the template nor the stylesheets, so we can create a stub for TypeScript always synchronously |
| // (as resource loading may be async) |
| var _this = this; |
| var styles = __spread(preparsedTemplate.styles); |
| this._inlineStyles(preparsedTemplate.inlineStyleUrls, stylesheets, styles); |
| var styleUrls = preparsedTemplate.styleUrls; |
| var externalStylesheets = styleUrls.map(function (styleUrl) { |
| var stylesheet = stylesheets.get(styleUrl); |
| var styles = __spread(stylesheet.styles); |
| _this._inlineStyles(stylesheet.styleUrls, stylesheets, styles); |
| return new CompileStylesheetMetadata({ moduleUrl: styleUrl, styles: styles }); |
| }); |
| var encapsulation = prenormData.encapsulation; |
| if (encapsulation == null) { |
| encapsulation = this._config.defaultEncapsulation; |
| } |
| if (encapsulation === ViewEncapsulation.Emulated && styles.length === 0 && |
| styleUrls.length === 0) { |
| encapsulation = ViewEncapsulation.None; |
| } |
| return new CompileTemplateMetadata({ |
| encapsulation: encapsulation, |
| template: preparsedTemplate.template, |
| templateUrl: preparsedTemplate.templateUrl, |
| htmlAst: preparsedTemplate.htmlAst, styles: styles, styleUrls: styleUrls, |
| ngContentSelectors: preparsedTemplate.ngContentSelectors, |
| animations: prenormData.animations, |
| interpolation: prenormData.interpolation, |
| isInline: preparsedTemplate.isInline, externalStylesheets: externalStylesheets, |
| preserveWhitespaces: preserveWhitespacesDefault(prenormData.preserveWhitespaces, this._config.preserveWhitespaces), |
| }); |
| }; |
| DirectiveNormalizer.prototype._inlineStyles = function (styleUrls, stylesheets, targetStyles) { |
| var _this = this; |
| styleUrls.forEach(function (styleUrl) { |
| var stylesheet = stylesheets.get(styleUrl); |
| stylesheet.styles.forEach(function (style) { return targetStyles.push(style); }); |
| _this._inlineStyles(stylesheet.styleUrls, stylesheets, targetStyles); |
| }); |
| }; |
| DirectiveNormalizer.prototype._loadMissingExternalStylesheets = function (styleUrls, loadedStylesheets) { |
| var _this = this; |
| if (loadedStylesheets === void 0) { loadedStylesheets = new Map(); } |
| return SyncAsync.then(SyncAsync.all(styleUrls.filter(function (styleUrl) { return !loadedStylesheets.has(styleUrl); }) |
| .map(function (styleUrl) { return SyncAsync.then(_this._fetch(styleUrl), function (loadedStyle) { |
| var stylesheet = _this._normalizeStylesheet(new CompileStylesheetMetadata({ styles: [loadedStyle], moduleUrl: styleUrl })); |
| loadedStylesheets.set(styleUrl, stylesheet); |
| return _this._loadMissingExternalStylesheets(stylesheet.styleUrls, loadedStylesheets); |
| }); })), function (_) { return loadedStylesheets; }); |
| }; |
| DirectiveNormalizer.prototype._normalizeStylesheet = function (stylesheet) { |
| var _this = this; |
| var moduleUrl = stylesheet.moduleUrl; |
| var allStyleUrls = stylesheet.styleUrls.filter(isStyleUrlResolvable) |
| .map(function (url) { return _this._urlResolver.resolve(moduleUrl, url); }); |
| var allStyles = stylesheet.styles.map(function (style) { |
| var styleWithImports = extractStyleUrls(_this._urlResolver, moduleUrl, style); |
| allStyleUrls.push.apply(allStyleUrls, __spread(styleWithImports.styleUrls)); |
| return styleWithImports.style; |
| }); |
| return new CompileStylesheetMetadata({ styles: allStyles, styleUrls: allStyleUrls, moduleUrl: moduleUrl }); |
| }; |
| return DirectiveNormalizer; |
| }()); |
| var TemplatePreparseVisitor = /** @class */ (function () { |
| function TemplatePreparseVisitor() { |
| this.ngContentSelectors = []; |
| this.styles = []; |
| this.styleUrls = []; |
| this.ngNonBindableStackCount = 0; |
| } |
| TemplatePreparseVisitor.prototype.visitElement = function (ast, context) { |
| var preparsedElement = preparseElement(ast); |
| switch (preparsedElement.type) { |
| case PreparsedElementType.NG_CONTENT: |
| if (this.ngNonBindableStackCount === 0) { |
| this.ngContentSelectors.push(preparsedElement.selectAttr); |
| } |
| break; |
| case PreparsedElementType.STYLE: |
| var textContent_1 = ''; |
| ast.children.forEach(function (child) { |
| if (child instanceof Text$3) { |
| textContent_1 += child.value; |
| } |
| }); |
| this.styles.push(textContent_1); |
| break; |
| case PreparsedElementType.STYLESHEET: |
| this.styleUrls.push(preparsedElement.hrefAttr); |
| break; |
| default: |
| break; |
| } |
| if (preparsedElement.nonBindable) { |
| this.ngNonBindableStackCount++; |
| } |
| visitAll$1(this, ast.children); |
| if (preparsedElement.nonBindable) { |
| this.ngNonBindableStackCount--; |
| } |
| return null; |
| }; |
| TemplatePreparseVisitor.prototype.visitExpansion = function (ast, context) { visitAll$1(this, ast.cases); }; |
| TemplatePreparseVisitor.prototype.visitExpansionCase = function (ast, context) { |
| visitAll$1(this, ast.expression); |
| }; |
| TemplatePreparseVisitor.prototype.visitComment = function (ast, context) { return null; }; |
| TemplatePreparseVisitor.prototype.visitAttribute = function (ast, context) { return null; }; |
| TemplatePreparseVisitor.prototype.visitText = function (ast, context) { return null; }; |
| return TemplatePreparseVisitor; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var QUERY_METADATA_IDENTIFIERS = [ |
| createViewChild, |
| createViewChildren, |
| createContentChild, |
| createContentChildren, |
| ]; |
| /* |
| * Resolve a `Type` for {@link Directive}. |
| * |
| * This interface can be overridden by the application developer to create custom behavior. |
| * |
| * See {@link Compiler} |
| */ |
| var DirectiveResolver = /** @class */ (function () { |
| function DirectiveResolver(_reflector) { |
| this._reflector = _reflector; |
| } |
| DirectiveResolver.prototype.isDirective = function (type) { |
| var typeMetadata = this._reflector.annotations(resolveForwardRef(type)); |
| return typeMetadata && typeMetadata.some(isDirectiveMetadata); |
| }; |
| DirectiveResolver.prototype.resolve = function (type, throwIfNotFound) { |
| if (throwIfNotFound === void 0) { throwIfNotFound = true; } |
| var typeMetadata = this._reflector.annotations(resolveForwardRef(type)); |
| if (typeMetadata) { |
| var metadata = findLast(typeMetadata, isDirectiveMetadata); |
| if (metadata) { |
| var propertyMetadata = this._reflector.propMetadata(type); |
| var guards = this._reflector.guards(type); |
| return this._mergeWithPropertyMetadata(metadata, propertyMetadata, guards, type); |
| } |
| } |
| if (throwIfNotFound) { |
| throw new Error("No Directive annotation found on " + stringify(type)); |
| } |
| return null; |
| }; |
| DirectiveResolver.prototype._mergeWithPropertyMetadata = function (dm, propertyMetadata, guards, directiveType) { |
| var inputs = []; |
| var outputs = []; |
| var host = {}; |
| var queries = {}; |
| Object.keys(propertyMetadata).forEach(function (propName) { |
| var input = findLast(propertyMetadata[propName], function (a) { return createInput.isTypeOf(a); }); |
| if (input) { |
| if (input.bindingPropertyName) { |
| inputs.push(propName + ": " + input.bindingPropertyName); |
| } |
| else { |
| inputs.push(propName); |
| } |
| } |
| var output = findLast(propertyMetadata[propName], function (a) { return createOutput.isTypeOf(a); }); |
| if (output) { |
| if (output.bindingPropertyName) { |
| outputs.push(propName + ": " + output.bindingPropertyName); |
| } |
| else { |
| outputs.push(propName); |
| } |
| } |
| var hostBindings = propertyMetadata[propName].filter(function (a) { return createHostBinding.isTypeOf(a); }); |
| hostBindings.forEach(function (hostBinding) { |
| if (hostBinding.hostPropertyName) { |
| var startWith = hostBinding.hostPropertyName[0]; |
| if (startWith === '(') { |
| throw new Error("@HostBinding can not bind to events. Use @HostListener instead."); |
| } |
| else if (startWith === '[') { |
| throw new Error("@HostBinding parameter should be a property name, 'class.<name>', or 'attr.<name>'."); |
| } |
| host["[" + hostBinding.hostPropertyName + "]"] = propName; |
| } |
| else { |
| host["[" + propName + "]"] = propName; |
| } |
| }); |
| var hostListeners = propertyMetadata[propName].filter(function (a) { return createHostListener.isTypeOf(a); }); |
| hostListeners.forEach(function (hostListener) { |
| var args = hostListener.args || []; |
| host["(" + hostListener.eventName + ")"] = propName + "(" + args.join(',') + ")"; |
| }); |
| var query = findLast(propertyMetadata[propName], function (a) { return QUERY_METADATA_IDENTIFIERS.some(function (i) { return i.isTypeOf(a); }); }); |
| if (query) { |
| queries[propName] = query; |
| } |
| }); |
| return this._merge(dm, inputs, outputs, host, queries, guards, directiveType); |
| }; |
| DirectiveResolver.prototype._extractPublicName = function (def) { return splitAtColon(def, [null, def])[1].trim(); }; |
| DirectiveResolver.prototype._dedupeBindings = function (bindings) { |
| var names = new Set(); |
| var publicNames = new Set(); |
| var reversedResult = []; |
| // go last to first to allow later entries to overwrite previous entries |
| for (var i = bindings.length - 1; i >= 0; i--) { |
| var binding = bindings[i]; |
| var name_1 = this._extractPublicName(binding); |
| publicNames.add(name_1); |
| if (!names.has(name_1)) { |
| names.add(name_1); |
| reversedResult.push(binding); |
| } |
| } |
| return reversedResult.reverse(); |
| }; |
| DirectiveResolver.prototype._merge = function (directive, inputs, outputs, host, queries, guards, directiveType) { |
| var mergedInputs = this._dedupeBindings(directive.inputs ? directive.inputs.concat(inputs) : inputs); |
| var mergedOutputs = this._dedupeBindings(directive.outputs ? directive.outputs.concat(outputs) : outputs); |
| var mergedHost = directive.host ? __assign({}, directive.host, host) : host; |
| var mergedQueries = directive.queries ? __assign({}, directive.queries, queries) : queries; |
| if (createComponent.isTypeOf(directive)) { |
| var comp = directive; |
| return createComponent({ |
| selector: comp.selector, |
| inputs: mergedInputs, |
| outputs: mergedOutputs, |
| host: mergedHost, |
| exportAs: comp.exportAs, |
| moduleId: comp.moduleId, |
| queries: mergedQueries, |
| changeDetection: comp.changeDetection, |
| providers: comp.providers, |
| viewProviders: comp.viewProviders, |
| entryComponents: comp.entryComponents, |
| template: comp.template, |
| templateUrl: comp.templateUrl, |
| styles: comp.styles, |
| styleUrls: comp.styleUrls, |
| encapsulation: comp.encapsulation, |
| animations: comp.animations, |
| interpolation: comp.interpolation, |
| preserveWhitespaces: directive.preserveWhitespaces, |
| }); |
| } |
| else { |
| return createDirective({ |
| selector: directive.selector, |
| inputs: mergedInputs, |
| outputs: mergedOutputs, |
| host: mergedHost, |
| exportAs: directive.exportAs, |
| queries: mergedQueries, |
| providers: directive.providers, guards: guards |
| }); |
| } |
| }; |
| return DirectiveResolver; |
| }()); |
| function isDirectiveMetadata(type) { |
| return createDirective.isTypeOf(type) || createComponent.isTypeOf(type); |
| } |
| function findLast(arr, condition) { |
| for (var i = arr.length - 1; i >= 0; i--) { |
| if (condition(arr[i])) { |
| return arr[i]; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * An i18n error. |
| */ |
| var I18nError = /** @class */ (function (_super) { |
| __extends(I18nError, _super); |
| function I18nError(span, msg) { |
| return _super.call(this, span, msg) || this; |
| } |
| return I18nError; |
| }(ParseError)); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var _I18N_ATTR = 'i18n'; |
| var _I18N_ATTR_PREFIX = 'i18n-'; |
| var _I18N_COMMENT_PREFIX_REGEXP = /^i18n:?/; |
| var MEANING_SEPARATOR = '|'; |
| var ID_SEPARATOR = '@@'; |
| var i18nCommentsWarned = false; |
| /** |
| * Extract translatable messages from an html AST |
| */ |
| function extractMessages(nodes, interpolationConfig, implicitTags, implicitAttrs) { |
| var visitor = new _Visitor$2(implicitTags, implicitAttrs); |
| return visitor.extract(nodes, interpolationConfig); |
| } |
| function mergeTranslations(nodes, translations, interpolationConfig, implicitTags, implicitAttrs) { |
| var visitor = new _Visitor$2(implicitTags, implicitAttrs); |
| return visitor.merge(nodes, translations, interpolationConfig); |
| } |
| var ExtractionResult = /** @class */ (function () { |
| function ExtractionResult(messages, errors) { |
| this.messages = messages; |
| this.errors = errors; |
| } |
| return ExtractionResult; |
| }()); |
| var _VisitorMode; |
| (function (_VisitorMode) { |
| _VisitorMode[_VisitorMode["Extract"] = 0] = "Extract"; |
| _VisitorMode[_VisitorMode["Merge"] = 1] = "Merge"; |
| })(_VisitorMode || (_VisitorMode = {})); |
| /** |
| * This Visitor is used: |
| * 1. to extract all the translatable strings from an html AST (see `extract()`), |
| * 2. to replace the translatable strings with the actual translations (see `merge()`) |
| * |
| * @internal |
| */ |
| var _Visitor$2 = /** @class */ (function () { |
| function _Visitor(_implicitTags, _implicitAttrs) { |
| this._implicitTags = _implicitTags; |
| this._implicitAttrs = _implicitAttrs; |
| } |
| /** |
| * Extracts the messages from the tree |
| */ |
| _Visitor.prototype.extract = function (nodes, interpolationConfig) { |
| var _this = this; |
| this._init(_VisitorMode.Extract, interpolationConfig); |
| nodes.forEach(function (node) { return node.visit(_this, null); }); |
| if (this._inI18nBlock) { |
| this._reportError(nodes[nodes.length - 1], 'Unclosed block'); |
| } |
| return new ExtractionResult(this._messages, this._errors); |
| }; |
| /** |
| * Returns a tree where all translatable nodes are translated |
| */ |
| _Visitor.prototype.merge = function (nodes, translations, interpolationConfig) { |
| this._init(_VisitorMode.Merge, interpolationConfig); |
| this._translations = translations; |
| // Construct a single fake root element |
| var wrapper = new Element$1('wrapper', [], nodes, undefined, undefined, undefined); |
| var translatedNode = wrapper.visit(this, null); |
| if (this._inI18nBlock) { |
| this._reportError(nodes[nodes.length - 1], 'Unclosed block'); |
| } |
| return new ParseTreeResult(translatedNode.children, this._errors); |
| }; |
| _Visitor.prototype.visitExpansionCase = function (icuCase, context) { |
| // Parse cases for translatable html attributes |
| var expression = visitAll$1(this, icuCase.expression, context); |
| if (this._mode === _VisitorMode.Merge) { |
| return new ExpansionCase(icuCase.value, expression, icuCase.sourceSpan, icuCase.valueSourceSpan, icuCase.expSourceSpan); |
| } |
| }; |
| _Visitor.prototype.visitExpansion = function (icu, context) { |
| this._mayBeAddBlockChildren(icu); |
| var wasInIcu = this._inIcu; |
| if (!this._inIcu) { |
| // nested ICU messages should not be extracted but top-level translated as a whole |
| if (this._isInTranslatableSection) { |
| this._addMessage([icu]); |
| } |
| this._inIcu = true; |
| } |
| var cases = visitAll$1(this, icu.cases, context); |
| if (this._mode === _VisitorMode.Merge) { |
| icu = new Expansion(icu.switchValue, icu.type, cases, icu.sourceSpan, icu.switchValueSourceSpan); |
| } |
| this._inIcu = wasInIcu; |
| return icu; |
| }; |
| _Visitor.prototype.visitComment = function (comment, context) { |
| var isOpening = _isOpeningComment(comment); |
| if (isOpening && this._isInTranslatableSection) { |
| this._reportError(comment, 'Could not start a block inside a translatable section'); |
| return; |
| } |
| var isClosing = _isClosingComment(comment); |
| if (isClosing && !this._inI18nBlock) { |
| this._reportError(comment, 'Trying to close an unopened block'); |
| return; |
| } |
| if (!this._inI18nNode && !this._inIcu) { |
| if (!this._inI18nBlock) { |
| if (isOpening) { |
| // deprecated from v5 you should use <ng-container i18n> instead of i18n comments |
| if (!i18nCommentsWarned && console && console.warn) { |
| i18nCommentsWarned = true; |
| var details = comment.sourceSpan.details ? ", " + comment.sourceSpan.details : ''; |
| // TODO(ocombe): use a log service once there is a public one available |
| console.warn("I18n comments are deprecated, use an <ng-container> element instead (" + comment.sourceSpan.start + details + ")"); |
| } |
| this._inI18nBlock = true; |
| this._blockStartDepth = this._depth; |
| this._blockChildren = []; |
| this._blockMeaningAndDesc = |
| comment.value.replace(_I18N_COMMENT_PREFIX_REGEXP, '').trim(); |
| this._openTranslatableSection(comment); |
| } |
| } |
| else { |
| if (isClosing) { |
| if (this._depth == this._blockStartDepth) { |
| this._closeTranslatableSection(comment, this._blockChildren); |
| this._inI18nBlock = false; |
| var message = this._addMessage(this._blockChildren, this._blockMeaningAndDesc); |
| // merge attributes in sections |
| var nodes = this._translateMessage(comment, message); |
| return visitAll$1(this, nodes); |
| } |
| else { |
| this._reportError(comment, 'I18N blocks should not cross element boundaries'); |
| return; |
| } |
| } |
| } |
| } |
| }; |
| _Visitor.prototype.visitText = function (text, context) { |
| if (this._isInTranslatableSection) { |
| this._mayBeAddBlockChildren(text); |
| } |
| return text; |
| }; |
| _Visitor.prototype.visitElement = function (el, context) { |
| var _this = this; |
| this._mayBeAddBlockChildren(el); |
| this._depth++; |
| var wasInI18nNode = this._inI18nNode; |
| var wasInImplicitNode = this._inImplicitNode; |
| var childNodes = []; |
| var translatedChildNodes = undefined; |
| // Extract: |
| // - top level nodes with the (implicit) "i18n" attribute if not already in a section |
| // - ICU messages |
| var i18nAttr = _getI18nAttr(el); |
| var i18nMeta = i18nAttr ? i18nAttr.value : ''; |
| var isImplicit = this._implicitTags.some(function (tag) { return el.name === tag; }) && !this._inIcu && |
| !this._isInTranslatableSection; |
| var isTopLevelImplicit = !wasInImplicitNode && isImplicit; |
| this._inImplicitNode = wasInImplicitNode || isImplicit; |
| if (!this._isInTranslatableSection && !this._inIcu) { |
| if (i18nAttr || isTopLevelImplicit) { |
| this._inI18nNode = true; |
| var message = this._addMessage(el.children, i18nMeta); |
| translatedChildNodes = this._translateMessage(el, message); |
| } |
| if (this._mode == _VisitorMode.Extract) { |
| var isTranslatable = i18nAttr || isTopLevelImplicit; |
| if (isTranslatable) |
| this._openTranslatableSection(el); |
| visitAll$1(this, el.children); |
| if (isTranslatable) |
| this._closeTranslatableSection(el, el.children); |
| } |
| } |
| else { |
| if (i18nAttr || isTopLevelImplicit) { |
| this._reportError(el, 'Could not mark an element as translatable inside a translatable section'); |
| } |
| if (this._mode == _VisitorMode.Extract) { |
| // Descend into child nodes for extraction |
| visitAll$1(this, el.children); |
| } |
| } |
| if (this._mode === _VisitorMode.Merge) { |
| var visitNodes = translatedChildNodes || el.children; |
| visitNodes.forEach(function (child) { |
| var visited = child.visit(_this, context); |
| if (visited && !_this._isInTranslatableSection) { |
| // Do not add the children from translatable sections (= i18n blocks here) |
| // They will be added later in this loop when the block closes (i.e. on `<!-- /i18n -->`) |
| childNodes = childNodes.concat(visited); |
| } |
| }); |
| } |
| this._visitAttributesOf(el); |
| this._depth--; |
| this._inI18nNode = wasInI18nNode; |
| this._inImplicitNode = wasInImplicitNode; |
| if (this._mode === _VisitorMode.Merge) { |
| var translatedAttrs = this._translateAttributes(el); |
| return new Element$1(el.name, translatedAttrs, childNodes, el.sourceSpan, el.startSourceSpan, el.endSourceSpan); |
| } |
| return null; |
| }; |
| _Visitor.prototype.visitAttribute = function (attribute, context) { |
| throw new Error('unreachable code'); |
| }; |
| _Visitor.prototype._init = function (mode, interpolationConfig) { |
| this._mode = mode; |
| this._inI18nBlock = false; |
| this._inI18nNode = false; |
| this._depth = 0; |
| this._inIcu = false; |
| this._msgCountAtSectionStart = undefined; |
| this._errors = []; |
| this._messages = []; |
| this._inImplicitNode = false; |
| this._createI18nMessage = createI18nMessageFactory(interpolationConfig); |
| }; |
| // looks for translatable attributes |
| _Visitor.prototype._visitAttributesOf = function (el) { |
| var _this = this; |
| var explicitAttrNameToValue = {}; |
| var implicitAttrNames = this._implicitAttrs[el.name] || []; |
| el.attrs.filter(function (attr) { return attr.name.startsWith(_I18N_ATTR_PREFIX); }) |
| .forEach(function (attr) { return explicitAttrNameToValue[attr.name.slice(_I18N_ATTR_PREFIX.length)] = |
| attr.value; }); |
| el.attrs.forEach(function (attr) { |
| if (attr.name in explicitAttrNameToValue) { |
| _this._addMessage([attr], explicitAttrNameToValue[attr.name]); |
| } |
| else if (implicitAttrNames.some(function (name) { return attr.name === name; })) { |
| _this._addMessage([attr]); |
| } |
| }); |
| }; |
| // add a translatable message |
| _Visitor.prototype._addMessage = function (ast, msgMeta) { |
| if (ast.length == 0 || |
| ast.length == 1 && ast[0] instanceof Attribute && !ast[0].value) { |
| // Do not create empty messages |
| return null; |
| } |
| var _a = _parseMessageMeta(msgMeta), meaning = _a.meaning, description = _a.description, id = _a.id; |
| var message = this._createI18nMessage(ast, meaning, description, id); |
| this._messages.push(message); |
| return message; |
| }; |
| // Translates the given message given the `TranslationBundle` |
| // This is used for translating elements / blocks - see `_translateAttributes` for attributes |
| // no-op when called in extraction mode (returns []) |
| _Visitor.prototype._translateMessage = function (el, message) { |
| if (message && this._mode === _VisitorMode.Merge) { |
| var nodes = this._translations.get(message); |
| if (nodes) { |
| return nodes; |
| } |
| this._reportError(el, "Translation unavailable for message id=\"" + this._translations.digest(message) + "\""); |
| } |
| return []; |
| }; |
| // translate the attributes of an element and remove i18n specific attributes |
| _Visitor.prototype._translateAttributes = function (el) { |
| var _this = this; |
| var attributes = el.attrs; |
| var i18nParsedMessageMeta = {}; |
| attributes.forEach(function (attr) { |
| if (attr.name.startsWith(_I18N_ATTR_PREFIX)) { |
| i18nParsedMessageMeta[attr.name.slice(_I18N_ATTR_PREFIX.length)] = |
| _parseMessageMeta(attr.value); |
| } |
| }); |
| var translatedAttributes = []; |
| attributes.forEach(function (attr) { |
| if (attr.name === _I18N_ATTR || attr.name.startsWith(_I18N_ATTR_PREFIX)) { |
| // strip i18n specific attributes |
| return; |
| } |
| if (attr.value && attr.value != '' && i18nParsedMessageMeta.hasOwnProperty(attr.name)) { |
| var _a = i18nParsedMessageMeta[attr.name], meaning = _a.meaning, description = _a.description, id = _a.id; |
| var message = _this._createI18nMessage([attr], meaning, description, id); |
| var nodes = _this._translations.get(message); |
| if (nodes) { |
| if (nodes.length == 0) { |
| translatedAttributes.push(new Attribute(attr.name, '', attr.sourceSpan)); |
| } |
| else if (nodes[0] instanceof Text$3) { |
| var value = nodes[0].value; |
| translatedAttributes.push(new Attribute(attr.name, value, attr.sourceSpan)); |
| } |
| else { |
| _this._reportError(el, "Unexpected translation for attribute \"" + attr.name + "\" (id=\"" + (id || _this._translations.digest(message)) + "\")"); |
| } |
| } |
| else { |
| _this._reportError(el, "Translation unavailable for attribute \"" + attr.name + "\" (id=\"" + (id || _this._translations.digest(message)) + "\")"); |
| } |
| } |
| else { |
| translatedAttributes.push(attr); |
| } |
| }); |
| return translatedAttributes; |
| }; |
| /** |
| * Add the node as a child of the block when: |
| * - we are in a block, |
| * - we are not inside a ICU message (those are handled separately), |
| * - the node is a "direct child" of the block |
| */ |
| _Visitor.prototype._mayBeAddBlockChildren = function (node) { |
| if (this._inI18nBlock && !this._inIcu && this._depth == this._blockStartDepth) { |
| this._blockChildren.push(node); |
| } |
| }; |
| /** |
| * Marks the start of a section, see `_closeTranslatableSection` |
| */ |
| _Visitor.prototype._openTranslatableSection = function (node) { |
| if (this._isInTranslatableSection) { |
| this._reportError(node, 'Unexpected section start'); |
| } |
| else { |
| this._msgCountAtSectionStart = this._messages.length; |
| } |
| }; |
| Object.defineProperty(_Visitor.prototype, "_isInTranslatableSection", { |
| /** |
| * A translatable section could be: |
| * - the content of translatable element, |
| * - nodes between `<!-- i18n -->` and `<!-- /i18n -->` comments |
| */ |
| get: function () { |
| return this._msgCountAtSectionStart !== void 0; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| /** |
| * Terminates a section. |
| * |
| * If a section has only one significant children (comments not significant) then we should not |
| * keep the message from this children: |
| * |
| * `<p i18n="meaning|description">{ICU message}</p>` would produce two messages: |
| * - one for the <p> content with meaning and description, |
| * - another one for the ICU message. |
| * |
| * In this case the last message is discarded as it contains less information (the AST is |
| * otherwise identical). |
| * |
| * Note that we should still keep messages extracted from attributes inside the section (ie in the |
| * ICU message here) |
| */ |
| _Visitor.prototype._closeTranslatableSection = function (node, directChildren) { |
| if (!this._isInTranslatableSection) { |
| this._reportError(node, 'Unexpected section end'); |
| return; |
| } |
| var startIndex = this._msgCountAtSectionStart; |
| var significantChildren = directChildren.reduce(function (count, node) { return count + (node instanceof Comment ? 0 : 1); }, 0); |
| if (significantChildren == 1) { |
| for (var i = this._messages.length - 1; i >= startIndex; i--) { |
| var ast = this._messages[i].nodes; |
| if (!(ast.length == 1 && ast[0] instanceof Text$1)) { |
| this._messages.splice(i, 1); |
| break; |
| } |
| } |
| } |
| this._msgCountAtSectionStart = undefined; |
| }; |
| _Visitor.prototype._reportError = function (node, msg) { |
| this._errors.push(new I18nError(node.sourceSpan, msg)); |
| }; |
| return _Visitor; |
| }()); |
| function _isOpeningComment(n) { |
| return !!(n instanceof Comment && n.value && n.value.startsWith('i18n')); |
| } |
| function _isClosingComment(n) { |
| return !!(n instanceof Comment && n.value && n.value === '/i18n'); |
| } |
| function _getI18nAttr(p) { |
| return p.attrs.find(function (attr) { return attr.name === _I18N_ATTR; }) || null; |
| } |
| function _parseMessageMeta(i18n) { |
| if (!i18n) |
| return { meaning: '', description: '', id: '' }; |
| var idIndex = i18n.indexOf(ID_SEPARATOR); |
| var descIndex = i18n.indexOf(MEANING_SEPARATOR); |
| var _a = __read((idIndex > -1) ? [i18n.slice(0, idIndex), i18n.slice(idIndex + 2)] : [i18n, ''], 2), meaningAndDesc = _a[0], id = _a[1]; |
| var _b = __read((descIndex > -1) ? |
| [meaningAndDesc.slice(0, descIndex), meaningAndDesc.slice(descIndex + 1)] : |
| ['', meaningAndDesc], 2), meaning = _b[0], description = _b[1]; |
| return { meaning: meaning, description: description, id: id }; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var XmlTagDefinition = /** @class */ (function () { |
| function XmlTagDefinition() { |
| this.closedByParent = false; |
| this.contentType = exports.TagContentType.PARSABLE_DATA; |
| this.isVoid = false; |
| this.ignoreFirstLf = false; |
| this.canSelfClose = true; |
| } |
| XmlTagDefinition.prototype.requireExtraParent = function (currentParent) { return false; }; |
| XmlTagDefinition.prototype.isClosedByChild = function (name) { return false; }; |
| return XmlTagDefinition; |
| }()); |
| var _TAG_DEFINITION = new XmlTagDefinition(); |
| function getXmlTagDefinition(tagName) { |
| return _TAG_DEFINITION; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var XmlParser = /** @class */ (function (_super) { |
| __extends(XmlParser, _super); |
| function XmlParser() { |
| return _super.call(this, getXmlTagDefinition) || this; |
| } |
| XmlParser.prototype.parse = function (source, url, options) { |
| return _super.prototype.parse.call(this, source, url, options); |
| }; |
| return XmlParser; |
| }(Parser)); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var _VERSION = '1.2'; |
| var _XMLNS = 'urn:oasis:names:tc:xliff:document:1.2'; |
| // TODO(vicb): make this a param (s/_/-/) |
| var _DEFAULT_SOURCE_LANG = 'en'; |
| var _PLACEHOLDER_TAG$1 = 'x'; |
| var _MARKER_TAG = 'mrk'; |
| var _FILE_TAG = 'file'; |
| var _SOURCE_TAG$1 = 'source'; |
| var _SEGMENT_SOURCE_TAG = 'seg-source'; |
| var _TARGET_TAG = 'target'; |
| var _UNIT_TAG = 'trans-unit'; |
| var _CONTEXT_GROUP_TAG = 'context-group'; |
| var _CONTEXT_TAG = 'context'; |
| // http://docs.oasis-open.org/xliff/v1.2/os/xliff-core.html |
| // http://docs.oasis-open.org/xliff/v1.2/xliff-profile-html/xliff-profile-html-1.2.html |
| var Xliff = /** @class */ (function (_super) { |
| __extends(Xliff, _super); |
| function Xliff() { |
| return _super !== null && _super.apply(this, arguments) || this; |
| } |
| Xliff.prototype.write = function (messages, locale) { |
| var visitor = new _WriteVisitor(); |
| var transUnits = []; |
| messages.forEach(function (message) { |
| var _a; |
| var contextTags = []; |
| message.sources.forEach(function (source) { |
| var contextGroupTag = new Tag(_CONTEXT_GROUP_TAG, { purpose: 'location' }); |
| contextGroupTag.children.push(new CR(10), new Tag(_CONTEXT_TAG, { 'context-type': 'sourcefile' }, [new Text$2(source.filePath)]), new CR(10), new Tag(_CONTEXT_TAG, { 'context-type': 'linenumber' }, [new Text$2("" + source.startLine)]), new CR(8)); |
| contextTags.push(new CR(8), contextGroupTag); |
| }); |
| var transUnit = new Tag(_UNIT_TAG, { id: message.id, datatype: 'html' }); |
| (_a = transUnit.children).push.apply(_a, __spread([new CR(8), new Tag(_SOURCE_TAG$1, {}, visitor.serialize(message.nodes))], contextTags)); |
| if (message.description) { |
| transUnit.children.push(new CR(8), new Tag('note', { priority: '1', from: 'description' }, [new Text$2(message.description)])); |
| } |
| if (message.meaning) { |
| transUnit.children.push(new CR(8), new Tag('note', { priority: '1', from: 'meaning' }, [new Text$2(message.meaning)])); |
| } |
| transUnit.children.push(new CR(6)); |
| transUnits.push(new CR(6), transUnit); |
| }); |
| var body = new Tag('body', {}, __spread(transUnits, [new CR(4)])); |
| var file = new Tag('file', { |
| 'source-language': locale || _DEFAULT_SOURCE_LANG, |
| datatype: 'plaintext', |
| original: 'ng2.template', |
| }, [new CR(4), body, new CR(2)]); |
| var xliff = new Tag('xliff', { version: _VERSION, xmlns: _XMLNS }, [new CR(2), file, new CR()]); |
| return serialize([ |
| new Declaration({ version: '1.0', encoding: 'UTF-8' }), new CR(), xliff, new CR() |
| ]); |
| }; |
| Xliff.prototype.load = function (content, url) { |
| // xliff to xml nodes |
| var xliffParser = new XliffParser(); |
| var _a = xliffParser.parse(content, url), locale = _a.locale, msgIdToHtml = _a.msgIdToHtml, errors = _a.errors; |
| // xml nodes to i18n nodes |
| var i18nNodesByMsgId = {}; |
| var converter = new XmlToI18n(); |
| Object.keys(msgIdToHtml).forEach(function (msgId) { |
| var _a = converter.convert(msgIdToHtml[msgId], url), i18nNodes = _a.i18nNodes, e = _a.errors; |
| errors.push.apply(errors, __spread(e)); |
| i18nNodesByMsgId[msgId] = i18nNodes; |
| }); |
| if (errors.length) { |
| throw new Error("xliff parse errors:\n" + errors.join('\n')); |
| } |
| return { locale: locale, i18nNodesByMsgId: i18nNodesByMsgId }; |
| }; |
| Xliff.prototype.digest = function (message) { return digest(message); }; |
| return Xliff; |
| }(Serializer)); |
| var _WriteVisitor = /** @class */ (function () { |
| function _WriteVisitor() { |
| } |
| _WriteVisitor.prototype.visitText = function (text, context) { return [new Text$2(text.value)]; }; |
| _WriteVisitor.prototype.visitContainer = function (container, context) { |
| var _this = this; |
| var nodes = []; |
| container.children.forEach(function (node) { return nodes.push.apply(nodes, __spread(node.visit(_this))); }); |
| return nodes; |
| }; |
| _WriteVisitor.prototype.visitIcu = function (icu, context) { |
| var _this = this; |
| var nodes = [new Text$2("{" + icu.expressionPlaceholder + ", " + icu.type + ", ")]; |
| Object.keys(icu.cases).forEach(function (c) { |
| nodes.push.apply(nodes, __spread([new Text$2(c + " {")], icu.cases[c].visit(_this), [new Text$2("} ")])); |
| }); |
| nodes.push(new Text$2("}")); |
| return nodes; |
| }; |
| _WriteVisitor.prototype.visitTagPlaceholder = function (ph, context) { |
| var ctype = getCtypeForTag(ph.tag); |
| if (ph.isVoid) { |
| // void tags have no children nor closing tags |
| return [new Tag(_PLACEHOLDER_TAG$1, { id: ph.startName, ctype: ctype, 'equiv-text': "<" + ph.tag + "/>" })]; |
| } |
| var startTagPh = new Tag(_PLACEHOLDER_TAG$1, { id: ph.startName, ctype: ctype, 'equiv-text': "<" + ph.tag + ">" }); |
| var closeTagPh = new Tag(_PLACEHOLDER_TAG$1, { id: ph.closeName, ctype: ctype, 'equiv-text': "</" + ph.tag + ">" }); |
| return __spread([startTagPh], this.serialize(ph.children), [closeTagPh]); |
| }; |
| _WriteVisitor.prototype.visitPlaceholder = function (ph, context) { |
| return [new Tag(_PLACEHOLDER_TAG$1, { id: ph.name, 'equiv-text': "{{" + ph.value + "}}" })]; |
| }; |
| _WriteVisitor.prototype.visitIcuPlaceholder = function (ph, context) { |
| var equivText = "{" + ph.value.expression + ", " + ph.value.type + ", " + Object.keys(ph.value.cases).map(function (value) { return value + ' {...}'; }).join(' ') + "}"; |
| return [new Tag(_PLACEHOLDER_TAG$1, { id: ph.name, 'equiv-text': equivText })]; |
| }; |
| _WriteVisitor.prototype.serialize = function (nodes) { |
| var _this = this; |
| return [].concat.apply([], __spread(nodes.map(function (node) { return node.visit(_this); }))); |
| }; |
| return _WriteVisitor; |
| }()); |
| // TODO(vicb): add error management (structure) |
| // Extract messages as xml nodes from the xliff file |
| var XliffParser = /** @class */ (function () { |
| function XliffParser() { |
| this._locale = null; |
| } |
| XliffParser.prototype.parse = function (xliff, url) { |
| this._unitMlString = null; |
| this._msgIdToHtml = {}; |
| var xml = new XmlParser().parse(xliff, url); |
| this._errors = xml.errors; |
| visitAll$1(this, xml.rootNodes, null); |
| return { |
| msgIdToHtml: this._msgIdToHtml, |
| errors: this._errors, |
| locale: this._locale, |
| }; |
| }; |
| XliffParser.prototype.visitElement = function (element, context) { |
| switch (element.name) { |
| case _UNIT_TAG: |
| this._unitMlString = null; |
| var idAttr = element.attrs.find(function (attr) { return attr.name === 'id'; }); |
| if (!idAttr) { |
| this._addError(element, "<" + _UNIT_TAG + "> misses the \"id\" attribute"); |
| } |
| else { |
| var id = idAttr.value; |
| if (this._msgIdToHtml.hasOwnProperty(id)) { |
| this._addError(element, "Duplicated translations for msg " + id); |
| } |
| else { |
| visitAll$1(this, element.children, null); |
| if (typeof this._unitMlString === 'string') { |
| this._msgIdToHtml[id] = this._unitMlString; |
| } |
| else { |
| this._addError(element, "Message " + id + " misses a translation"); |
| } |
| } |
| } |
| break; |
| // ignore those tags |
| case _SOURCE_TAG$1: |
| case _SEGMENT_SOURCE_TAG: |
| break; |
| case _TARGET_TAG: |
| var innerTextStart = element.startSourceSpan.end.offset; |
| var innerTextEnd = element.endSourceSpan.start.offset; |
| var content = element.startSourceSpan.start.file.content; |
| var innerText = content.slice(innerTextStart, innerTextEnd); |
| this._unitMlString = innerText; |
| break; |
| case _FILE_TAG: |
| var localeAttr = element.attrs.find(function (attr) { return attr.name === 'target-language'; }); |
| if (localeAttr) { |
| this._locale = localeAttr.value; |
| } |
| visitAll$1(this, element.children, null); |
| break; |
| default: |
| // TODO(vicb): assert file structure, xliff version |
| // For now only recurse on unhandled nodes |
| visitAll$1(this, element.children, null); |
| } |
| }; |
| XliffParser.prototype.visitAttribute = function (attribute, context) { }; |
| XliffParser.prototype.visitText = function (text, context) { }; |
| XliffParser.prototype.visitComment = function (comment, context) { }; |
| XliffParser.prototype.visitExpansion = function (expansion, context) { }; |
| XliffParser.prototype.visitExpansionCase = function (expansionCase, context) { }; |
| XliffParser.prototype._addError = function (node, message) { |
| this._errors.push(new I18nError(node.sourceSpan, message)); |
| }; |
| return XliffParser; |
| }()); |
| // Convert ml nodes (xliff syntax) to i18n nodes |
| var XmlToI18n = /** @class */ (function () { |
| function XmlToI18n() { |
| } |
| XmlToI18n.prototype.convert = function (message, url) { |
| var xmlIcu = new XmlParser().parse(message, url, { tokenizeExpansionForms: true }); |
| this._errors = xmlIcu.errors; |
| var i18nNodes = this._errors.length > 0 || xmlIcu.rootNodes.length == 0 ? |
| [] : [].concat.apply([], __spread(visitAll$1(this, xmlIcu.rootNodes))); |
| return { |
| i18nNodes: i18nNodes, |
| errors: this._errors, |
| }; |
| }; |
| XmlToI18n.prototype.visitText = function (text, context) { return new Text$1(text.value, text.sourceSpan); }; |
| XmlToI18n.prototype.visitElement = function (el, context) { |
| if (el.name === _PLACEHOLDER_TAG$1) { |
| var nameAttr = el.attrs.find(function (attr) { return attr.name === 'id'; }); |
| if (nameAttr) { |
| return new Placeholder('', nameAttr.value, el.sourceSpan); |
| } |
| this._addError(el, "<" + _PLACEHOLDER_TAG$1 + "> misses the \"id\" attribute"); |
| return null; |
| } |
| if (el.name === _MARKER_TAG) { |
| return [].concat.apply([], __spread(visitAll$1(this, el.children))); |
| } |
| this._addError(el, "Unexpected tag"); |
| return null; |
| }; |
| XmlToI18n.prototype.visitExpansion = function (icu, context) { |
| var caseMap = {}; |
| visitAll$1(this, icu.cases).forEach(function (c) { |
| caseMap[c.value] = new Container(c.nodes, icu.sourceSpan); |
| }); |
| return new Icu$1(icu.switchValue, icu.type, caseMap, icu.sourceSpan); |
| }; |
| XmlToI18n.prototype.visitExpansionCase = function (icuCase, context) { |
| return { |
| value: icuCase.value, |
| nodes: visitAll$1(this, icuCase.expression), |
| }; |
| }; |
| XmlToI18n.prototype.visitComment = function (comment, context) { }; |
| XmlToI18n.prototype.visitAttribute = function (attribute, context) { }; |
| XmlToI18n.prototype._addError = function (node, message) { |
| this._errors.push(new I18nError(node.sourceSpan, message)); |
| }; |
| return XmlToI18n; |
| }()); |
| function getCtypeForTag(tag) { |
| switch (tag.toLowerCase()) { |
| case 'br': |
| return 'lb'; |
| case 'img': |
| return 'image'; |
| default: |
| return "x-" + tag; |
| } |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var _VERSION$1 = '2.0'; |
| var _XMLNS$1 = 'urn:oasis:names:tc:xliff:document:2.0'; |
| // TODO(vicb): make this a param (s/_/-/) |
| var _DEFAULT_SOURCE_LANG$1 = 'en'; |
| var _PLACEHOLDER_TAG$2 = 'ph'; |
| var _PLACEHOLDER_SPANNING_TAG = 'pc'; |
| var _MARKER_TAG$1 = 'mrk'; |
| var _XLIFF_TAG = 'xliff'; |
| var _SOURCE_TAG$2 = 'source'; |
| var _TARGET_TAG$1 = 'target'; |
| var _UNIT_TAG$1 = 'unit'; |
| // http://docs.oasis-open.org/xliff/xliff-core/v2.0/os/xliff-core-v2.0-os.html |
| var Xliff2 = /** @class */ (function (_super) { |
| __extends(Xliff2, _super); |
| function Xliff2() { |
| return _super !== null && _super.apply(this, arguments) || this; |
| } |
| Xliff2.prototype.write = function (messages, locale) { |
| var visitor = new _WriteVisitor$1(); |
| var units = []; |
| messages.forEach(function (message) { |
| var unit = new Tag(_UNIT_TAG$1, { id: message.id }); |
| var notes = new Tag('notes'); |
| if (message.description || message.meaning) { |
| if (message.description) { |
| notes.children.push(new CR(8), new Tag('note', { category: 'description' }, [new Text$2(message.description)])); |
| } |
| if (message.meaning) { |
| notes.children.push(new CR(8), new Tag('note', { category: 'meaning' }, [new Text$2(message.meaning)])); |
| } |
| } |
| message.sources.forEach(function (source) { |
| notes.children.push(new CR(8), new Tag('note', { category: 'location' }, [ |
| new Text$2(source.filePath + ":" + source.startLine + (source.endLine !== source.startLine ? ',' + source.endLine : '')) |
| ])); |
| }); |
| notes.children.push(new CR(6)); |
| unit.children.push(new CR(6), notes); |
| var segment = new Tag('segment'); |
| segment.children.push(new CR(8), new Tag(_SOURCE_TAG$2, {}, visitor.serialize(message.nodes)), new CR(6)); |
| unit.children.push(new CR(6), segment, new CR(4)); |
| units.push(new CR(4), unit); |
| }); |
| var file = new Tag('file', { 'original': 'ng.template', id: 'ngi18n' }, __spread(units, [new CR(2)])); |
| var xliff = new Tag(_XLIFF_TAG, { version: _VERSION$1, xmlns: _XMLNS$1, srcLang: locale || _DEFAULT_SOURCE_LANG$1 }, [new CR(2), file, new CR()]); |
| return serialize([ |
| new Declaration({ version: '1.0', encoding: 'UTF-8' }), new CR(), xliff, new CR() |
| ]); |
| }; |
| Xliff2.prototype.load = function (content, url) { |
| // xliff to xml nodes |
| var xliff2Parser = new Xliff2Parser(); |
| var _a = xliff2Parser.parse(content, url), locale = _a.locale, msgIdToHtml = _a.msgIdToHtml, errors = _a.errors; |
| // xml nodes to i18n nodes |
| var i18nNodesByMsgId = {}; |
| var converter = new XmlToI18n$1(); |
| Object.keys(msgIdToHtml).forEach(function (msgId) { |
| var _a = converter.convert(msgIdToHtml[msgId], url), i18nNodes = _a.i18nNodes, e = _a.errors; |
| errors.push.apply(errors, __spread(e)); |
| i18nNodesByMsgId[msgId] = i18nNodes; |
| }); |
| if (errors.length) { |
| throw new Error("xliff2 parse errors:\n" + errors.join('\n')); |
| } |
| return { locale: locale, i18nNodesByMsgId: i18nNodesByMsgId }; |
| }; |
| Xliff2.prototype.digest = function (message) { return decimalDigest(message); }; |
| return Xliff2; |
| }(Serializer)); |
| var _WriteVisitor$1 = /** @class */ (function () { |
| function _WriteVisitor() { |
| } |
| _WriteVisitor.prototype.visitText = function (text, context) { return [new Text$2(text.value)]; }; |
| _WriteVisitor.prototype.visitContainer = function (container, context) { |
| var _this = this; |
| var nodes = []; |
| container.children.forEach(function (node) { return nodes.push.apply(nodes, __spread(node.visit(_this))); }); |
| return nodes; |
| }; |
| _WriteVisitor.prototype.visitIcu = function (icu, context) { |
| var _this = this; |
| var nodes = [new Text$2("{" + icu.expressionPlaceholder + ", " + icu.type + ", ")]; |
| Object.keys(icu.cases).forEach(function (c) { |
| nodes.push.apply(nodes, __spread([new Text$2(c + " {")], icu.cases[c].visit(_this), [new Text$2("} ")])); |
| }); |
| nodes.push(new Text$2("}")); |
| return nodes; |
| }; |
| _WriteVisitor.prototype.visitTagPlaceholder = function (ph, context) { |
| var _this = this; |
| var type = getTypeForTag(ph.tag); |
| if (ph.isVoid) { |
| var tagPh = new Tag(_PLACEHOLDER_TAG$2, { |
| id: (this._nextPlaceholderId++).toString(), |
| equiv: ph.startName, |
| type: type, |
| disp: "<" + ph.tag + "/>", |
| }); |
| return [tagPh]; |
| } |
| var tagPc = new Tag(_PLACEHOLDER_SPANNING_TAG, { |
| id: (this._nextPlaceholderId++).toString(), |
| equivStart: ph.startName, |
| equivEnd: ph.closeName, |
| type: type, |
| dispStart: "<" + ph.tag + ">", |
| dispEnd: "</" + ph.tag + ">", |
| }); |
| var nodes = [].concat.apply([], __spread(ph.children.map(function (node) { return node.visit(_this); }))); |
| if (nodes.length) { |
| nodes.forEach(function (node) { return tagPc.children.push(node); }); |
| } |
| else { |
| tagPc.children.push(new Text$2('')); |
| } |
| return [tagPc]; |
| }; |
| _WriteVisitor.prototype.visitPlaceholder = function (ph, context) { |
| var idStr = (this._nextPlaceholderId++).toString(); |
| return [new Tag(_PLACEHOLDER_TAG$2, { |
| id: idStr, |
| equiv: ph.name, |
| disp: "{{" + ph.value + "}}", |
| })]; |
| }; |
| _WriteVisitor.prototype.visitIcuPlaceholder = function (ph, context) { |
| var cases = Object.keys(ph.value.cases).map(function (value) { return value + ' {...}'; }).join(' '); |
| var idStr = (this._nextPlaceholderId++).toString(); |
| return [new Tag(_PLACEHOLDER_TAG$2, { id: idStr, equiv: ph.name, disp: "{" + ph.value.expression + ", " + ph.value.type + ", " + cases + "}" })]; |
| }; |
| _WriteVisitor.prototype.serialize = function (nodes) { |
| var _this = this; |
| this._nextPlaceholderId = 0; |
| return [].concat.apply([], __spread(nodes.map(function (node) { return node.visit(_this); }))); |
| }; |
| return _WriteVisitor; |
| }()); |
| // Extract messages as xml nodes from the xliff file |
| var Xliff2Parser = /** @class */ (function () { |
| function Xliff2Parser() { |
| this._locale = null; |
| } |
| Xliff2Parser.prototype.parse = function (xliff, url) { |
| this._unitMlString = null; |
| this._msgIdToHtml = {}; |
| var xml = new XmlParser().parse(xliff, url); |
| this._errors = xml.errors; |
| visitAll$1(this, xml.rootNodes, null); |
| return { |
| msgIdToHtml: this._msgIdToHtml, |
| errors: this._errors, |
| locale: this._locale, |
| }; |
| }; |
| Xliff2Parser.prototype.visitElement = function (element, context) { |
| switch (element.name) { |
| case _UNIT_TAG$1: |
| this._unitMlString = null; |
| var idAttr = element.attrs.find(function (attr) { return attr.name === 'id'; }); |
| if (!idAttr) { |
| this._addError(element, "<" + _UNIT_TAG$1 + "> misses the \"id\" attribute"); |
| } |
| else { |
| var id = idAttr.value; |
| if (this._msgIdToHtml.hasOwnProperty(id)) { |
| this._addError(element, "Duplicated translations for msg " + id); |
| } |
| else { |
| visitAll$1(this, element.children, null); |
| if (typeof this._unitMlString === 'string') { |
| this._msgIdToHtml[id] = this._unitMlString; |
| } |
| else { |
| this._addError(element, "Message " + id + " misses a translation"); |
| } |
| } |
| } |
| break; |
| case _SOURCE_TAG$2: |
| // ignore source message |
| break; |
| case _TARGET_TAG$1: |
| var innerTextStart = element.startSourceSpan.end.offset; |
| var innerTextEnd = element.endSourceSpan.start.offset; |
| var content = element.startSourceSpan.start.file.content; |
| var innerText = content.slice(innerTextStart, innerTextEnd); |
| this._unitMlString = innerText; |
| break; |
| case _XLIFF_TAG: |
| var localeAttr = element.attrs.find(function (attr) { return attr.name === 'trgLang'; }); |
| if (localeAttr) { |
| this._locale = localeAttr.value; |
| } |
| var versionAttr = element.attrs.find(function (attr) { return attr.name === 'version'; }); |
| if (versionAttr) { |
| var version = versionAttr.value; |
| if (version !== '2.0') { |
| this._addError(element, "The XLIFF file version " + version + " is not compatible with XLIFF 2.0 serializer"); |
| } |
| else { |
| visitAll$1(this, element.children, null); |
| } |
| } |
| break; |
| default: |
| visitAll$1(this, element.children, null); |
| } |
| }; |
| Xliff2Parser.prototype.visitAttribute = function (attribute, context) { }; |
| Xliff2Parser.prototype.visitText = function (text, context) { }; |
| Xliff2Parser.prototype.visitComment = function (comment, context) { }; |
| Xliff2Parser.prototype.visitExpansion = function (expansion, context) { }; |
| Xliff2Parser.prototype.visitExpansionCase = function (expansionCase, context) { }; |
| Xliff2Parser.prototype._addError = function (node, message) { |
| this._errors.push(new I18nError(node.sourceSpan, message)); |
| }; |
| return Xliff2Parser; |
| }()); |
| // Convert ml nodes (xliff syntax) to i18n nodes |
| var XmlToI18n$1 = /** @class */ (function () { |
| function XmlToI18n() { |
| } |
| XmlToI18n.prototype.convert = function (message, url) { |
| var xmlIcu = new XmlParser().parse(message, url, { tokenizeExpansionForms: true }); |
| this._errors = xmlIcu.errors; |
| var i18nNodes = this._errors.length > 0 || xmlIcu.rootNodes.length == 0 ? |
| [] : [].concat.apply([], __spread(visitAll$1(this, xmlIcu.rootNodes))); |
| return { |
| i18nNodes: i18nNodes, |
| errors: this._errors, |
| }; |
| }; |
| XmlToI18n.prototype.visitText = function (text, context) { return new Text$1(text.value, text.sourceSpan); }; |
| XmlToI18n.prototype.visitElement = function (el, context) { |
| var _this = this; |
| switch (el.name) { |
| case _PLACEHOLDER_TAG$2: |
| var nameAttr = el.attrs.find(function (attr) { return attr.name === 'equiv'; }); |
| if (nameAttr) { |
| return [new Placeholder('', nameAttr.value, el.sourceSpan)]; |
| } |
| this._addError(el, "<" + _PLACEHOLDER_TAG$2 + "> misses the \"equiv\" attribute"); |
| break; |
| case _PLACEHOLDER_SPANNING_TAG: |
| var startAttr = el.attrs.find(function (attr) { return attr.name === 'equivStart'; }); |
| var endAttr = el.attrs.find(function (attr) { return attr.name === 'equivEnd'; }); |
| if (!startAttr) { |
| this._addError(el, "<" + _PLACEHOLDER_TAG$2 + "> misses the \"equivStart\" attribute"); |
| } |
| else if (!endAttr) { |
| this._addError(el, "<" + _PLACEHOLDER_TAG$2 + "> misses the \"equivEnd\" attribute"); |
| } |
| else { |
| var startId = startAttr.value; |
| var endId = endAttr.value; |
| var nodes = []; |
| return nodes.concat.apply(nodes, __spread([new Placeholder('', startId, el.sourceSpan)], el.children.map(function (node) { return node.visit(_this, null); }), [new Placeholder('', endId, el.sourceSpan)])); |
| } |
| break; |
| case _MARKER_TAG$1: |
| return [].concat.apply([], __spread(visitAll$1(this, el.children))); |
| default: |
| this._addError(el, "Unexpected tag"); |
| } |
| return null; |
| }; |
| XmlToI18n.prototype.visitExpansion = function (icu, context) { |
| var caseMap = {}; |
| visitAll$1(this, icu.cases).forEach(function (c) { |
| caseMap[c.value] = new Container(c.nodes, icu.sourceSpan); |
| }); |
| return new Icu$1(icu.switchValue, icu.type, caseMap, icu.sourceSpan); |
| }; |
| XmlToI18n.prototype.visitExpansionCase = function (icuCase, context) { |
| return { |
| value: icuCase.value, |
| nodes: [].concat.apply([], __spread(visitAll$1(this, icuCase.expression))), |
| }; |
| }; |
| XmlToI18n.prototype.visitComment = function (comment, context) { }; |
| XmlToI18n.prototype.visitAttribute = function (attribute, context) { }; |
| XmlToI18n.prototype._addError = function (node, message) { |
| this._errors.push(new I18nError(node.sourceSpan, message)); |
| }; |
| return XmlToI18n; |
| }()); |
| function getTypeForTag(tag) { |
| switch (tag.toLowerCase()) { |
| case 'br': |
| case 'b': |
| case 'i': |
| case 'u': |
| return 'fmt'; |
| case 'img': |
| return 'image'; |
| case 'a': |
| return 'link'; |
| default: |
| return 'other'; |
| } |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var _TRANSLATIONS_TAG = 'translationbundle'; |
| var _TRANSLATION_TAG = 'translation'; |
| var _PLACEHOLDER_TAG$3 = 'ph'; |
| var Xtb = /** @class */ (function (_super) { |
| __extends(Xtb, _super); |
| function Xtb() { |
| return _super !== null && _super.apply(this, arguments) || this; |
| } |
| Xtb.prototype.write = function (messages, locale) { throw new Error('Unsupported'); }; |
| Xtb.prototype.load = function (content, url) { |
| // xtb to xml nodes |
| var xtbParser = new XtbParser(); |
| var _a = xtbParser.parse(content, url), locale = _a.locale, msgIdToHtml = _a.msgIdToHtml, errors = _a.errors; |
| // xml nodes to i18n nodes |
| var i18nNodesByMsgId = {}; |
| var converter = new XmlToI18n$2(); |
| // Because we should be able to load xtb files that rely on features not supported by angular, |
| // we need to delay the conversion of html to i18n nodes so that non angular messages are not |
| // converted |
| Object.keys(msgIdToHtml).forEach(function (msgId) { |
| var valueFn = function () { |
| var _a = converter.convert(msgIdToHtml[msgId], url), i18nNodes = _a.i18nNodes, errors = _a.errors; |
| if (errors.length) { |
| throw new Error("xtb parse errors:\n" + errors.join('\n')); |
| } |
| return i18nNodes; |
| }; |
| createLazyProperty(i18nNodesByMsgId, msgId, valueFn); |
| }); |
| if (errors.length) { |
| throw new Error("xtb parse errors:\n" + errors.join('\n')); |
| } |
| return { locale: locale, i18nNodesByMsgId: i18nNodesByMsgId }; |
| }; |
| Xtb.prototype.digest = function (message) { return digest$1(message); }; |
| Xtb.prototype.createNameMapper = function (message) { |
| return new SimplePlaceholderMapper(message, toPublicName); |
| }; |
| return Xtb; |
| }(Serializer)); |
| function createLazyProperty(messages, id, valueFn) { |
| Object.defineProperty(messages, id, { |
| configurable: true, |
| enumerable: true, |
| get: function () { |
| var value = valueFn(); |
| Object.defineProperty(messages, id, { enumerable: true, value: value }); |
| return value; |
| }, |
| set: function (_) { throw new Error('Could not overwrite an XTB translation'); }, |
| }); |
| } |
| // Extract messages as xml nodes from the xtb file |
| var XtbParser = /** @class */ (function () { |
| function XtbParser() { |
| this._locale = null; |
| } |
| XtbParser.prototype.parse = function (xtb, url) { |
| this._bundleDepth = 0; |
| this._msgIdToHtml = {}; |
| // We can not parse the ICU messages at this point as some messages might not originate |
| // from Angular that could not be lex'd. |
| var xml = new XmlParser().parse(xtb, url); |
| this._errors = xml.errors; |
| visitAll$1(this, xml.rootNodes); |
| return { |
| msgIdToHtml: this._msgIdToHtml, |
| errors: this._errors, |
| locale: this._locale, |
| }; |
| }; |
| XtbParser.prototype.visitElement = function (element, context) { |
| switch (element.name) { |
| case _TRANSLATIONS_TAG: |
| this._bundleDepth++; |
| if (this._bundleDepth > 1) { |
| this._addError(element, "<" + _TRANSLATIONS_TAG + "> elements can not be nested"); |
| } |
| var langAttr = element.attrs.find(function (attr) { return attr.name === 'lang'; }); |
| if (langAttr) { |
| this._locale = langAttr.value; |
| } |
| visitAll$1(this, element.children, null); |
| this._bundleDepth--; |
| break; |
| case _TRANSLATION_TAG: |
| var idAttr = element.attrs.find(function (attr) { return attr.name === 'id'; }); |
| if (!idAttr) { |
| this._addError(element, "<" + _TRANSLATION_TAG + "> misses the \"id\" attribute"); |
| } |
| else { |
| var id = idAttr.value; |
| if (this._msgIdToHtml.hasOwnProperty(id)) { |
| this._addError(element, "Duplicated translations for msg " + id); |
| } |
| else { |
| var innerTextStart = element.startSourceSpan.end.offset; |
| var innerTextEnd = element.endSourceSpan.start.offset; |
| var content = element.startSourceSpan.start.file.content; |
| var innerText = content.slice(innerTextStart, innerTextEnd); |
| this._msgIdToHtml[id] = innerText; |
| } |
| } |
| break; |
| default: |
| this._addError(element, 'Unexpected tag'); |
| } |
| }; |
| XtbParser.prototype.visitAttribute = function (attribute, context) { }; |
| XtbParser.prototype.visitText = function (text, context) { }; |
| XtbParser.prototype.visitComment = function (comment, context) { }; |
| XtbParser.prototype.visitExpansion = function (expansion, context) { }; |
| XtbParser.prototype.visitExpansionCase = function (expansionCase, context) { }; |
| XtbParser.prototype._addError = function (node, message) { |
| this._errors.push(new I18nError(node.sourceSpan, message)); |
| }; |
| return XtbParser; |
| }()); |
| // Convert ml nodes (xtb syntax) to i18n nodes |
| var XmlToI18n$2 = /** @class */ (function () { |
| function XmlToI18n() { |
| } |
| XmlToI18n.prototype.convert = function (message, url) { |
| var xmlIcu = new XmlParser().parse(message, url, { tokenizeExpansionForms: true }); |
| this._errors = xmlIcu.errors; |
| var i18nNodes = this._errors.length > 0 || xmlIcu.rootNodes.length == 0 ? |
| [] : |
| visitAll$1(this, xmlIcu.rootNodes); |
| return { |
| i18nNodes: i18nNodes, |
| errors: this._errors, |
| }; |
| }; |
| XmlToI18n.prototype.visitText = function (text, context) { return new Text$1(text.value, text.sourceSpan); }; |
| XmlToI18n.prototype.visitExpansion = function (icu, context) { |
| var caseMap = {}; |
| visitAll$1(this, icu.cases).forEach(function (c) { |
| caseMap[c.value] = new Container(c.nodes, icu.sourceSpan); |
| }); |
| return new Icu$1(icu.switchValue, icu.type, caseMap, icu.sourceSpan); |
| }; |
| XmlToI18n.prototype.visitExpansionCase = function (icuCase, context) { |
| return { |
| value: icuCase.value, |
| nodes: visitAll$1(this, icuCase.expression), |
| }; |
| }; |
| XmlToI18n.prototype.visitElement = function (el, context) { |
| if (el.name === _PLACEHOLDER_TAG$3) { |
| var nameAttr = el.attrs.find(function (attr) { return attr.name === 'name'; }); |
| if (nameAttr) { |
| return new Placeholder('', nameAttr.value, el.sourceSpan); |
| } |
| this._addError(el, "<" + _PLACEHOLDER_TAG$3 + "> misses the \"name\" attribute"); |
| } |
| else { |
| this._addError(el, "Unexpected tag"); |
| } |
| return null; |
| }; |
| XmlToI18n.prototype.visitComment = function (comment, context) { }; |
| XmlToI18n.prototype.visitAttribute = function (attribute, context) { }; |
| XmlToI18n.prototype._addError = function (node, message) { |
| this._errors.push(new I18nError(node.sourceSpan, message)); |
| }; |
| return XmlToI18n; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * A container for translated messages |
| */ |
| var TranslationBundle = /** @class */ (function () { |
| function TranslationBundle(_i18nNodesByMsgId, locale, digest, mapperFactory, missingTranslationStrategy, console) { |
| if (_i18nNodesByMsgId === void 0) { _i18nNodesByMsgId = {}; } |
| if (missingTranslationStrategy === void 0) { missingTranslationStrategy = MissingTranslationStrategy.Warning; } |
| this._i18nNodesByMsgId = _i18nNodesByMsgId; |
| this.digest = digest; |
| this.mapperFactory = mapperFactory; |
| this._i18nToHtml = new I18nToHtmlVisitor(_i18nNodesByMsgId, locale, digest, mapperFactory, missingTranslationStrategy, console); |
| } |
| // Creates a `TranslationBundle` by parsing the given `content` with the `serializer`. |
| TranslationBundle.load = function (content, url, serializer, missingTranslationStrategy, console) { |
| var _a = serializer.load(content, url), locale = _a.locale, i18nNodesByMsgId = _a.i18nNodesByMsgId; |
| var digestFn = function (m) { return serializer.digest(m); }; |
| var mapperFactory = function (m) { return serializer.createNameMapper(m); }; |
| return new TranslationBundle(i18nNodesByMsgId, locale, digestFn, mapperFactory, missingTranslationStrategy, console); |
| }; |
| // Returns the translation as HTML nodes from the given source message. |
| TranslationBundle.prototype.get = function (srcMsg) { |
| var html = this._i18nToHtml.convert(srcMsg); |
| if (html.errors.length) { |
| throw new Error(html.errors.join('\n')); |
| } |
| return html.nodes; |
| }; |
| TranslationBundle.prototype.has = function (srcMsg) { return this.digest(srcMsg) in this._i18nNodesByMsgId; }; |
| return TranslationBundle; |
| }()); |
| var I18nToHtmlVisitor = /** @class */ (function () { |
| function I18nToHtmlVisitor(_i18nNodesByMsgId, _locale, _digest, _mapperFactory, _missingTranslationStrategy, _console) { |
| if (_i18nNodesByMsgId === void 0) { _i18nNodesByMsgId = {}; } |
| this._i18nNodesByMsgId = _i18nNodesByMsgId; |
| this._locale = _locale; |
| this._digest = _digest; |
| this._mapperFactory = _mapperFactory; |
| this._missingTranslationStrategy = _missingTranslationStrategy; |
| this._console = _console; |
| this._contextStack = []; |
| this._errors = []; |
| } |
| I18nToHtmlVisitor.prototype.convert = function (srcMsg) { |
| this._contextStack.length = 0; |
| this._errors.length = 0; |
| // i18n to text |
| var text = this._convertToText(srcMsg); |
| // text to html |
| var url = srcMsg.nodes[0].sourceSpan.start.file.url; |
| var html = new HtmlParser().parse(text, url, { tokenizeExpansionForms: true }); |
| return { |
| nodes: html.rootNodes, |
| errors: __spread(this._errors, html.errors), |
| }; |
| }; |
| I18nToHtmlVisitor.prototype.visitText = function (text, context) { |
| // `convert()` uses an `HtmlParser` to return `html.Node`s |
| // we should then make sure that any special characters are escaped |
| return escapeXml(text.value); |
| }; |
| I18nToHtmlVisitor.prototype.visitContainer = function (container, context) { |
| var _this = this; |
| return container.children.map(function (n) { return n.visit(_this); }).join(''); |
| }; |
| I18nToHtmlVisitor.prototype.visitIcu = function (icu, context) { |
| var _this = this; |
| var cases = Object.keys(icu.cases).map(function (k) { return k + " {" + icu.cases[k].visit(_this) + "}"; }); |
| // TODO(vicb): Once all format switch to using expression placeholders |
| // we should throw when the placeholder is not in the source message |
| var exp = this._srcMsg.placeholders.hasOwnProperty(icu.expression) ? |
| this._srcMsg.placeholders[icu.expression] : |
| icu.expression; |
| return "{" + exp + ", " + icu.type + ", " + cases.join(' ') + "}"; |
| }; |
| I18nToHtmlVisitor.prototype.visitPlaceholder = function (ph, context) { |
| var phName = this._mapper(ph.name); |
| if (this._srcMsg.placeholders.hasOwnProperty(phName)) { |
| return this._srcMsg.placeholders[phName]; |
| } |
| if (this._srcMsg.placeholderToMessage.hasOwnProperty(phName)) { |
| return this._convertToText(this._srcMsg.placeholderToMessage[phName]); |
| } |
| this._addError(ph, "Unknown placeholder \"" + ph.name + "\""); |
| return ''; |
| }; |
| // Loaded message contains only placeholders (vs tag and icu placeholders). |
| // However when a translation can not be found, we need to serialize the source message |
| // which can contain tag placeholders |
| I18nToHtmlVisitor.prototype.visitTagPlaceholder = function (ph, context) { |
| var _this = this; |
| var tag = "" + ph.tag; |
| var attrs = Object.keys(ph.attrs).map(function (name) { return name + "=\"" + ph.attrs[name] + "\""; }).join(' '); |
| if (ph.isVoid) { |
| return "<" + tag + " " + attrs + "/>"; |
| } |
| var children = ph.children.map(function (c) { return c.visit(_this); }).join(''); |
| return "<" + tag + " " + attrs + ">" + children + "</" + tag + ">"; |
| }; |
| // Loaded message contains only placeholders (vs tag and icu placeholders). |
| // However when a translation can not be found, we need to serialize the source message |
| // which can contain tag placeholders |
| I18nToHtmlVisitor.prototype.visitIcuPlaceholder = function (ph, context) { |
| // An ICU placeholder references the source message to be serialized |
| return this._convertToText(this._srcMsg.placeholderToMessage[ph.name]); |
| }; |
| /** |
| * Convert a source message to a translated text string: |
| * - text nodes are replaced with their translation, |
| * - placeholders are replaced with their content, |
| * - ICU nodes are converted to ICU expressions. |
| */ |
| I18nToHtmlVisitor.prototype._convertToText = function (srcMsg) { |
| var _this = this; |
| var id = this._digest(srcMsg); |
| var mapper = this._mapperFactory ? this._mapperFactory(srcMsg) : null; |
| var nodes; |
| this._contextStack.push({ msg: this._srcMsg, mapper: this._mapper }); |
| this._srcMsg = srcMsg; |
| if (this._i18nNodesByMsgId.hasOwnProperty(id)) { |
| // When there is a translation use its nodes as the source |
| // And create a mapper to convert serialized placeholder names to internal names |
| nodes = this._i18nNodesByMsgId[id]; |
| this._mapper = function (name) { return mapper ? mapper.toInternalName(name) : name; }; |
| } |
| else { |
| // When no translation has been found |
| // - report an error / a warning / nothing, |
| // - use the nodes from the original message |
| // - placeholders are already internal and need no mapper |
| if (this._missingTranslationStrategy === MissingTranslationStrategy.Error) { |
| var ctx = this._locale ? " for locale \"" + this._locale + "\"" : ''; |
| this._addError(srcMsg.nodes[0], "Missing translation for message \"" + id + "\"" + ctx); |
| } |
| else if (this._console && |
| this._missingTranslationStrategy === MissingTranslationStrategy.Warning) { |
| var ctx = this._locale ? " for locale \"" + this._locale + "\"" : ''; |
| this._console.warn("Missing translation for message \"" + id + "\"" + ctx); |
| } |
| nodes = srcMsg.nodes; |
| this._mapper = function (name) { return name; }; |
| } |
| var text = nodes.map(function (node) { return node.visit(_this); }).join(''); |
| var context = this._contextStack.pop(); |
| this._srcMsg = context.msg; |
| this._mapper = context.mapper; |
| return text; |
| }; |
| I18nToHtmlVisitor.prototype._addError = function (el, msg) { |
| this._errors.push(new I18nError(el.sourceSpan, msg)); |
| }; |
| return I18nToHtmlVisitor; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var I18NHtmlParser = /** @class */ (function () { |
| function I18NHtmlParser(_htmlParser, translations, translationsFormat, missingTranslation, console) { |
| if (missingTranslation === void 0) { missingTranslation = MissingTranslationStrategy.Warning; } |
| this._htmlParser = _htmlParser; |
| if (translations) { |
| var serializer = createSerializer(translationsFormat); |
| this._translationBundle = |
| TranslationBundle.load(translations, 'i18n', serializer, missingTranslation, console); |
| } |
| else { |
| this._translationBundle = |
| new TranslationBundle({}, null, digest, undefined, missingTranslation, console); |
| } |
| } |
| I18NHtmlParser.prototype.parse = function (source, url, options) { |
| if (options === void 0) { options = {}; } |
| var interpolationConfig = options.interpolationConfig || DEFAULT_INTERPOLATION_CONFIG; |
| var parseResult = this._htmlParser.parse(source, url, __assign({ interpolationConfig: interpolationConfig }, options)); |
| if (parseResult.errors.length) { |
| return new ParseTreeResult(parseResult.rootNodes, parseResult.errors); |
| } |
| return mergeTranslations(parseResult.rootNodes, this._translationBundle, interpolationConfig, [], {}); |
| }; |
| return I18NHtmlParser; |
| }()); |
| function createSerializer(format) { |
| format = (format || 'xlf').toLowerCase(); |
| switch (format) { |
| case 'xmb': |
| return new Xmb(); |
| case 'xtb': |
| return new Xtb(); |
| case 'xliff2': |
| case 'xlf2': |
| return new Xliff2(); |
| case 'xliff': |
| case 'xlf': |
| default: |
| return new Xliff(); |
| } |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var QUOTED_KEYS = '$quoted$'; |
| function convertValueToOutputAst(ctx, value, type) { |
| if (type === void 0) { type = null; } |
| return visitValue(value, new _ValueOutputAstTransformer(ctx), type); |
| } |
| var _ValueOutputAstTransformer = /** @class */ (function () { |
| function _ValueOutputAstTransformer(ctx) { |
| this.ctx = ctx; |
| } |
| _ValueOutputAstTransformer.prototype.visitArray = function (arr, type) { |
| var _this = this; |
| return literalArr(arr.map(function (value) { return visitValue(value, _this, null); }), type); |
| }; |
| _ValueOutputAstTransformer.prototype.visitStringMap = function (map, type) { |
| var _this = this; |
| var entries = []; |
| var quotedSet = new Set(map && map[QUOTED_KEYS]); |
| Object.keys(map).forEach(function (key) { |
| entries.push(new LiteralMapEntry(key, visitValue(map[key], _this, null), quotedSet.has(key))); |
| }); |
| return new LiteralMapExpr(entries, type); |
| }; |
| _ValueOutputAstTransformer.prototype.visitPrimitive = function (value, type) { return literal(value, type); }; |
| _ValueOutputAstTransformer.prototype.visitOther = function (value, type) { |
| if (value instanceof Expression) { |
| return value; |
| } |
| else { |
| return this.ctx.importExpr(value); |
| } |
| }; |
| return _ValueOutputAstTransformer; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| function mapEntry(key, value) { |
| return { key: key, value: value, quoted: false }; |
| } |
| var InjectableCompiler = /** @class */ (function () { |
| function InjectableCompiler(reflector, alwaysGenerateDef) { |
| this.reflector = reflector; |
| this.alwaysGenerateDef = alwaysGenerateDef; |
| this.tokenInjector = reflector.resolveExternalReference(Identifiers.Injector); |
| } |
| InjectableCompiler.prototype.depsArray = function (deps, ctx) { |
| var _this = this; |
| return deps.map(function (dep) { |
| var token = dep; |
| var args = [token]; |
| var flags = 0 /* Default */; |
| if (Array.isArray(dep)) { |
| for (var i = 0; i < dep.length; i++) { |
| var v = dep[i]; |
| if (v) { |
| if (v.ngMetadataName === 'Optional') { |
| flags |= 8 /* Optional */; |
| } |
| else if (v.ngMetadataName === 'SkipSelf') { |
| flags |= 4 /* SkipSelf */; |
| } |
| else if (v.ngMetadataName === 'Self') { |
| flags |= 2 /* Self */; |
| } |
| else if (v.ngMetadataName === 'Inject') { |
| token = v.token; |
| } |
| else { |
| token = v; |
| } |
| } |
| } |
| } |
| var tokenExpr; |
| if (typeof token === 'string') { |
| tokenExpr = literal(token); |
| } |
| else if (token === _this.tokenInjector) { |
| tokenExpr = importExpr(Identifiers.INJECTOR); |
| } |
| else { |
| tokenExpr = ctx.importExpr(token); |
| } |
| if (flags !== 0 /* Default */) { |
| args = [tokenExpr, literal(flags)]; |
| } |
| else { |
| args = [tokenExpr]; |
| } |
| return importExpr(Identifiers.inject).callFn(args); |
| }); |
| }; |
| InjectableCompiler.prototype.factoryFor = function (injectable, ctx) { |
| var retValue; |
| if (injectable.useExisting) { |
| retValue = importExpr(Identifiers.inject).callFn([ctx.importExpr(injectable.useExisting)]); |
| } |
| else if (injectable.useFactory) { |
| var deps = injectable.deps || []; |
| if (deps.length > 0) { |
| retValue = ctx.importExpr(injectable.useFactory).callFn(this.depsArray(deps, ctx)); |
| } |
| else { |
| return ctx.importExpr(injectable.useFactory); |
| } |
| } |
| else if (injectable.useValue) { |
| retValue = convertValueToOutputAst(ctx, injectable.useValue); |
| } |
| else { |
| var clazz = injectable.useClass || injectable.symbol; |
| var depArgs = this.depsArray(this.reflector.parameters(clazz), ctx); |
| retValue = new InstantiateExpr(ctx.importExpr(clazz), depArgs); |
| } |
| return fn([], [new ReturnStatement(retValue)], undefined, undefined, injectable.symbol.name + '_Factory'); |
| }; |
| InjectableCompiler.prototype.injectableDef = function (injectable, ctx) { |
| var providedIn = NULL_EXPR; |
| if (injectable.providedIn !== undefined) { |
| if (injectable.providedIn === null) { |
| providedIn = NULL_EXPR; |
| } |
| else if (typeof injectable.providedIn === 'string') { |
| providedIn = literal(injectable.providedIn); |
| } |
| else { |
| providedIn = ctx.importExpr(injectable.providedIn); |
| } |
| } |
| var def = [ |
| mapEntry('factory', this.factoryFor(injectable, ctx)), |
| mapEntry('token', ctx.importExpr(injectable.type.reference)), |
| mapEntry('providedIn', providedIn), |
| ]; |
| return importExpr(Identifiers.ɵɵdefineInjectable).callFn([literalMap(def)]); |
| }; |
| InjectableCompiler.prototype.compile = function (injectable, ctx) { |
| if (this.alwaysGenerateDef || injectable.providedIn !== undefined) { |
| var className = identifierName(injectable.type); |
| var clazz = new ClassStmt(className, null, [ |
| new ClassField('ngInjectableDef', INFERRED_TYPE, [exports.StmtModifier.Static], this.injectableDef(injectable, ctx)), |
| ], [], new ClassMethod(null, [], []), []); |
| ctx.statements.push(clazz); |
| } |
| }; |
| return InjectableCompiler; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var STRIP_SRC_FILE_SUFFIXES = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/; |
| var GENERATED_FILE = /\.ngfactory\.|\.ngsummary\./; |
| var JIT_SUMMARY_FILE = /\.ngsummary\./; |
| var JIT_SUMMARY_NAME = /NgSummary$/; |
| function ngfactoryFilePath(filePath, forceSourceFile) { |
| if (forceSourceFile === void 0) { forceSourceFile = false; } |
| var urlWithSuffix = splitTypescriptSuffix(filePath, forceSourceFile); |
| return urlWithSuffix[0] + ".ngfactory" + normalizeGenFileSuffix(urlWithSuffix[1]); |
| } |
| function stripGeneratedFileSuffix(filePath) { |
| return filePath.replace(GENERATED_FILE, '.'); |
| } |
| function isGeneratedFile(filePath) { |
| return GENERATED_FILE.test(filePath); |
| } |
| function splitTypescriptSuffix(path, forceSourceFile) { |
| if (forceSourceFile === void 0) { forceSourceFile = false; } |
| if (path.endsWith('.d.ts')) { |
| return [path.slice(0, -5), forceSourceFile ? '.ts' : '.d.ts']; |
| } |
| var lastDot = path.lastIndexOf('.'); |
| if (lastDot !== -1) { |
| return [path.substring(0, lastDot), path.substring(lastDot)]; |
| } |
| return [path, '']; |
| } |
| function normalizeGenFileSuffix(srcFileSuffix) { |
| return srcFileSuffix === '.tsx' ? '.ts' : srcFileSuffix; |
| } |
| function summaryFileName(fileName) { |
| var fileNameWithoutSuffix = fileName.replace(STRIP_SRC_FILE_SUFFIXES, ''); |
| return fileNameWithoutSuffix + ".ngsummary.json"; |
| } |
| function summaryForJitFileName(fileName, forceSourceFile) { |
| if (forceSourceFile === void 0) { forceSourceFile = false; } |
| var urlWithSuffix = splitTypescriptSuffix(stripGeneratedFileSuffix(fileName), forceSourceFile); |
| return urlWithSuffix[0] + ".ngsummary" + urlWithSuffix[1]; |
| } |
| function stripSummaryForJitFileSuffix(filePath) { |
| return filePath.replace(JIT_SUMMARY_FILE, '.'); |
| } |
| function summaryForJitName(symbolName) { |
| return symbolName + "NgSummary"; |
| } |
| function stripSummaryForJitNameSuffix(symbolName) { |
| return symbolName.replace(JIT_SUMMARY_NAME, ''); |
| } |
| var LOWERED_SYMBOL = /\u0275\d+/; |
| function isLoweredSymbol(name) { |
| return LOWERED_SYMBOL.test(name); |
| } |
| function createLoweredSymbol(id) { |
| return "\u0275" + id; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var LifecycleHooks; |
| (function (LifecycleHooks) { |
| LifecycleHooks[LifecycleHooks["OnInit"] = 0] = "OnInit"; |
| LifecycleHooks[LifecycleHooks["OnDestroy"] = 1] = "OnDestroy"; |
| LifecycleHooks[LifecycleHooks["DoCheck"] = 2] = "DoCheck"; |
| LifecycleHooks[LifecycleHooks["OnChanges"] = 3] = "OnChanges"; |
| LifecycleHooks[LifecycleHooks["AfterContentInit"] = 4] = "AfterContentInit"; |
| LifecycleHooks[LifecycleHooks["AfterContentChecked"] = 5] = "AfterContentChecked"; |
| LifecycleHooks[LifecycleHooks["AfterViewInit"] = 6] = "AfterViewInit"; |
| LifecycleHooks[LifecycleHooks["AfterViewChecked"] = 7] = "AfterViewChecked"; |
| })(LifecycleHooks || (LifecycleHooks = {})); |
| var LIFECYCLE_HOOKS_VALUES = [ |
| LifecycleHooks.OnInit, LifecycleHooks.OnDestroy, LifecycleHooks.DoCheck, LifecycleHooks.OnChanges, |
| LifecycleHooks.AfterContentInit, LifecycleHooks.AfterContentChecked, LifecycleHooks.AfterViewInit, |
| LifecycleHooks.AfterViewChecked |
| ]; |
| function hasLifecycleHook(reflector, hook, token) { |
| return reflector.hasLifecycleHook(token, getHookName(hook)); |
| } |
| function getAllLifecycleHooks(reflector, token) { |
| return LIFECYCLE_HOOKS_VALUES.filter(function (hook) { return hasLifecycleHook(reflector, hook, token); }); |
| } |
| function getHookName(hook) { |
| switch (hook) { |
| case LifecycleHooks.OnInit: |
| return 'ngOnInit'; |
| case LifecycleHooks.OnDestroy: |
| return 'ngOnDestroy'; |
| case LifecycleHooks.DoCheck: |
| return 'ngDoCheck'; |
| case LifecycleHooks.OnChanges: |
| return 'ngOnChanges'; |
| case LifecycleHooks.AfterContentInit: |
| return 'ngAfterContentInit'; |
| case LifecycleHooks.AfterContentChecked: |
| return 'ngAfterContentChecked'; |
| case LifecycleHooks.AfterViewInit: |
| return 'ngAfterViewInit'; |
| case LifecycleHooks.AfterViewChecked: |
| return 'ngAfterViewChecked'; |
| default: |
| // This default case is not needed by TypeScript compiler, as the switch is exhaustive. |
| // However Closure Compiler does not understand that and reports an error in typed mode. |
| // The `throw new Error` below works around the problem, and the unexpected: never variable |
| // makes sure tsc still checks this code is unreachable. |
| var unexpected = hook; |
| throw new Error("unexpected " + unexpected); |
| } |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var ERROR_COMPONENT_TYPE = 'ngComponentType'; |
| // Design notes: |
| // - don't lazily create metadata: |
| // For some metadata, we need to do async work sometimes, |
| // so the user has to kick off this loading. |
| // But we want to report errors even when the async work is |
| // not required to check that the user would have been able |
| // to wait correctly. |
| var CompileMetadataResolver = /** @class */ (function () { |
| function CompileMetadataResolver(_config, _htmlParser, _ngModuleResolver, _directiveResolver, _pipeResolver, _summaryResolver, _schemaRegistry, _directiveNormalizer, _console, _staticSymbolCache, _reflector, _errorCollector) { |
| this._config = _config; |
| this._htmlParser = _htmlParser; |
| this._ngModuleResolver = _ngModuleResolver; |
| this._directiveResolver = _directiveResolver; |
| this._pipeResolver = _pipeResolver; |
| this._summaryResolver = _summaryResolver; |
| this._schemaRegistry = _schemaRegistry; |
| this._directiveNormalizer = _directiveNormalizer; |
| this._console = _console; |
| this._staticSymbolCache = _staticSymbolCache; |
| this._reflector = _reflector; |
| this._errorCollector = _errorCollector; |
| this._nonNormalizedDirectiveCache = new Map(); |
| this._directiveCache = new Map(); |
| this._summaryCache = new Map(); |
| this._pipeCache = new Map(); |
| this._ngModuleCache = new Map(); |
| this._ngModuleOfTypes = new Map(); |
| this._shallowModuleCache = new Map(); |
| } |
| CompileMetadataResolver.prototype.getReflector = function () { return this._reflector; }; |
| CompileMetadataResolver.prototype.clearCacheFor = function (type) { |
| var dirMeta = this._directiveCache.get(type); |
| this._directiveCache.delete(type); |
| this._nonNormalizedDirectiveCache.delete(type); |
| this._summaryCache.delete(type); |
| this._pipeCache.delete(type); |
| this._ngModuleOfTypes.delete(type); |
| // Clear all of the NgModule as they contain transitive information! |
| this._ngModuleCache.clear(); |
| if (dirMeta) { |
| this._directiveNormalizer.clearCacheFor(dirMeta); |
| } |
| }; |
| CompileMetadataResolver.prototype.clearCache = function () { |
| this._directiveCache.clear(); |
| this._nonNormalizedDirectiveCache.clear(); |
| this._summaryCache.clear(); |
| this._pipeCache.clear(); |
| this._ngModuleCache.clear(); |
| this._ngModuleOfTypes.clear(); |
| this._directiveNormalizer.clearCache(); |
| }; |
| CompileMetadataResolver.prototype._createProxyClass = function (baseType, name) { |
| var delegate = null; |
| var proxyClass = function () { |
| if (!delegate) { |
| throw new Error("Illegal state: Class " + name + " for type " + stringify(baseType) + " is not compiled yet!"); |
| } |
| return delegate.apply(this, arguments); |
| }; |
| proxyClass.setDelegate = function (d) { |
| delegate = d; |
| proxyClass.prototype = d.prototype; |
| }; |
| // Make stringify work correctly |
| proxyClass.overriddenName = name; |
| return proxyClass; |
| }; |
| CompileMetadataResolver.prototype.getGeneratedClass = function (dirType, name) { |
| if (dirType instanceof StaticSymbol) { |
| return this._staticSymbolCache.get(ngfactoryFilePath(dirType.filePath), name); |
| } |
| else { |
| return this._createProxyClass(dirType, name); |
| } |
| }; |
| CompileMetadataResolver.prototype.getComponentViewClass = function (dirType) { |
| return this.getGeneratedClass(dirType, viewClassName(dirType, 0)); |
| }; |
| CompileMetadataResolver.prototype.getHostComponentViewClass = function (dirType) { |
| return this.getGeneratedClass(dirType, hostViewClassName(dirType)); |
| }; |
| CompileMetadataResolver.prototype.getHostComponentType = function (dirType) { |
| var name = identifierName({ reference: dirType }) + "_Host"; |
| if (dirType instanceof StaticSymbol) { |
| return this._staticSymbolCache.get(dirType.filePath, name); |
| } |
| return this._createProxyClass(dirType, name); |
| }; |
| CompileMetadataResolver.prototype.getRendererType = function (dirType) { |
| if (dirType instanceof StaticSymbol) { |
| return this._staticSymbolCache.get(ngfactoryFilePath(dirType.filePath), rendererTypeName(dirType)); |
| } |
| else { |
| // returning an object as proxy, |
| // that we fill later during runtime compilation. |
| return {}; |
| } |
| }; |
| CompileMetadataResolver.prototype.getComponentFactory = function (selector, dirType, inputs, outputs) { |
| if (dirType instanceof StaticSymbol) { |
| return this._staticSymbolCache.get(ngfactoryFilePath(dirType.filePath), componentFactoryName(dirType)); |
| } |
| else { |
| var hostView = this.getHostComponentViewClass(dirType); |
| // Note: ngContentSelectors will be filled later once the template is |
| // loaded. |
| var createComponentFactory = this._reflector.resolveExternalReference(Identifiers.createComponentFactory); |
| return createComponentFactory(selector, dirType, hostView, inputs, outputs, []); |
| } |
| }; |
| CompileMetadataResolver.prototype.initComponentFactory = function (factory, ngContentSelectors) { |
| var _a; |
| if (!(factory instanceof StaticSymbol)) { |
| (_a = factory.ngContentSelectors).push.apply(_a, __spread(ngContentSelectors)); |
| } |
| }; |
| CompileMetadataResolver.prototype._loadSummary = function (type, kind) { |
| var typeSummary = this._summaryCache.get(type); |
| if (!typeSummary) { |
| var summary = this._summaryResolver.resolveSummary(type); |
| typeSummary = summary ? summary.type : null; |
| this._summaryCache.set(type, typeSummary || null); |
| } |
| return typeSummary && typeSummary.summaryKind === kind ? typeSummary : null; |
| }; |
| CompileMetadataResolver.prototype.getHostComponentMetadata = function (compMeta, hostViewType) { |
| var hostType = this.getHostComponentType(compMeta.type.reference); |
| if (!hostViewType) { |
| hostViewType = this.getHostComponentViewClass(hostType); |
| } |
| // Note: ! is ok here as this method should only be called with normalized directive |
| // metadata, which always fills in the selector. |
| var template = CssSelector.parse(compMeta.selector)[0].getMatchingElementTemplate(); |
| var templateUrl = ''; |
| var htmlAst = this._htmlParser.parse(template, templateUrl); |
| return CompileDirectiveMetadata.create({ |
| isHost: true, |
| type: { reference: hostType, diDeps: [], lifecycleHooks: [] }, |
| template: new CompileTemplateMetadata({ |
| encapsulation: ViewEncapsulation.None, |
| template: template, |
| templateUrl: templateUrl, |
| htmlAst: htmlAst, |
| styles: [], |
| styleUrls: [], |
| ngContentSelectors: [], |
| animations: [], |
| isInline: true, |
| externalStylesheets: [], |
| interpolation: null, |
| preserveWhitespaces: false, |
| }), |
| exportAs: null, |
| changeDetection: ChangeDetectionStrategy.Default, |
| inputs: [], |
| outputs: [], |
| host: {}, |
| isComponent: true, |
| selector: '*', |
| providers: [], |
| viewProviders: [], |
| queries: [], |
| guards: {}, |
| viewQueries: [], |
| componentViewType: hostViewType, |
| rendererType: { id: '__Host__', encapsulation: ViewEncapsulation.None, styles: [], data: {} }, |
| entryComponents: [], |
| componentFactory: null |
| }); |
| }; |
| CompileMetadataResolver.prototype.loadDirectiveMetadata = function (ngModuleType, directiveType, isSync) { |
| var _this = this; |
| if (this._directiveCache.has(directiveType)) { |
| return null; |
| } |
| directiveType = resolveForwardRef(directiveType); |
| var _a = this.getNonNormalizedDirectiveMetadata(directiveType), annotation = _a.annotation, metadata = _a.metadata; |
| var createDirectiveMetadata = function (templateMetadata) { |
| var normalizedDirMeta = new CompileDirectiveMetadata({ |
| isHost: false, |
| type: metadata.type, |
| isComponent: metadata.isComponent, |
| selector: metadata.selector, |
| exportAs: metadata.exportAs, |
| changeDetection: metadata.changeDetection, |
| inputs: metadata.inputs, |
| outputs: metadata.outputs, |
| hostListeners: metadata.hostListeners, |
| hostProperties: metadata.hostProperties, |
| hostAttributes: metadata.hostAttributes, |
| providers: metadata.providers, |
| viewProviders: metadata.viewProviders, |
| queries: metadata.queries, |
| guards: metadata.guards, |
| viewQueries: metadata.viewQueries, |
| entryComponents: metadata.entryComponents, |
| componentViewType: metadata.componentViewType, |
| rendererType: metadata.rendererType, |
| componentFactory: metadata.componentFactory, |
| template: templateMetadata |
| }); |
| if (templateMetadata) { |
| _this.initComponentFactory(metadata.componentFactory, templateMetadata.ngContentSelectors); |
| } |
| _this._directiveCache.set(directiveType, normalizedDirMeta); |
| _this._summaryCache.set(directiveType, normalizedDirMeta.toSummary()); |
| return null; |
| }; |
| if (metadata.isComponent) { |
| var template = metadata.template; |
| var templateMeta = this._directiveNormalizer.normalizeTemplate({ |
| ngModuleType: ngModuleType, |
| componentType: directiveType, |
| moduleUrl: this._reflector.componentModuleUrl(directiveType, annotation), |
| encapsulation: template.encapsulation, |
| template: template.template, |
| templateUrl: template.templateUrl, |
| styles: template.styles, |
| styleUrls: template.styleUrls, |
| animations: template.animations, |
| interpolation: template.interpolation, |
| preserveWhitespaces: template.preserveWhitespaces |
| }); |
| if (isPromise(templateMeta) && isSync) { |
| this._reportError(componentStillLoadingError(directiveType), directiveType); |
| return null; |
| } |
| return SyncAsync.then(templateMeta, createDirectiveMetadata); |
| } |
| else { |
| // directive |
| createDirectiveMetadata(null); |
| return null; |
| } |
| }; |
| CompileMetadataResolver.prototype.getNonNormalizedDirectiveMetadata = function (directiveType) { |
| var _this = this; |
| directiveType = resolveForwardRef(directiveType); |
| if (!directiveType) { |
| return null; |
| } |
| var cacheEntry = this._nonNormalizedDirectiveCache.get(directiveType); |
| if (cacheEntry) { |
| return cacheEntry; |
| } |
| var dirMeta = this._directiveResolver.resolve(directiveType, false); |
| if (!dirMeta) { |
| return null; |
| } |
| var nonNormalizedTemplateMetadata = undefined; |
| if (createComponent.isTypeOf(dirMeta)) { |
| // component |
| var compMeta = dirMeta; |
| assertArrayOfStrings('styles', compMeta.styles); |
| assertArrayOfStrings('styleUrls', compMeta.styleUrls); |
| assertInterpolationSymbols('interpolation', compMeta.interpolation); |
| var animations = compMeta.animations; |
| nonNormalizedTemplateMetadata = new CompileTemplateMetadata({ |
| encapsulation: noUndefined(compMeta.encapsulation), |
| template: noUndefined(compMeta.template), |
| templateUrl: noUndefined(compMeta.templateUrl), |
| htmlAst: null, |
| styles: compMeta.styles || [], |
| styleUrls: compMeta.styleUrls || [], |
| animations: animations || [], |
| interpolation: noUndefined(compMeta.interpolation), |
| isInline: !!compMeta.template, |
| externalStylesheets: [], |
| ngContentSelectors: [], |
| preserveWhitespaces: noUndefined(dirMeta.preserveWhitespaces), |
| }); |
| } |
| var changeDetectionStrategy = null; |
| var viewProviders = []; |
| var entryComponentMetadata = []; |
| var selector = dirMeta.selector; |
| if (createComponent.isTypeOf(dirMeta)) { |
| // Component |
| var compMeta = dirMeta; |
| changeDetectionStrategy = compMeta.changeDetection; |
| if (compMeta.viewProviders) { |
| viewProviders = this._getProvidersMetadata(compMeta.viewProviders, entryComponentMetadata, "viewProviders for \"" + stringifyType(directiveType) + "\"", [], directiveType); |
| } |
| if (compMeta.entryComponents) { |
| entryComponentMetadata = flattenAndDedupeArray(compMeta.entryComponents) |
| .map(function (type) { return _this._getEntryComponentMetadata(type); }) |
| .concat(entryComponentMetadata); |
| } |
| if (!selector) { |
| selector = this._schemaRegistry.getDefaultComponentElementName(); |
| } |
| } |
| else { |
| // Directive |
| if (!selector) { |
| this._reportError(syntaxError("Directive " + stringifyType(directiveType) + " has no selector, please add it!"), directiveType); |
| selector = 'error'; |
| } |
| } |
| var providers = []; |
| if (dirMeta.providers != null) { |
| providers = this._getProvidersMetadata(dirMeta.providers, entryComponentMetadata, "providers for \"" + stringifyType(directiveType) + "\"", [], directiveType); |
| } |
| var queries = []; |
| var viewQueries = []; |
| if (dirMeta.queries != null) { |
| queries = this._getQueriesMetadata(dirMeta.queries, false, directiveType); |
| viewQueries = this._getQueriesMetadata(dirMeta.queries, true, directiveType); |
| } |
| var metadata = CompileDirectiveMetadata.create({ |
| isHost: false, |
| selector: selector, |
| exportAs: noUndefined(dirMeta.exportAs), |
| isComponent: !!nonNormalizedTemplateMetadata, |
| type: this._getTypeMetadata(directiveType), |
| template: nonNormalizedTemplateMetadata, |
| changeDetection: changeDetectionStrategy, |
| inputs: dirMeta.inputs || [], |
| outputs: dirMeta.outputs || [], |
| host: dirMeta.host || {}, |
| providers: providers || [], |
| viewProviders: viewProviders || [], |
| queries: queries || [], |
| guards: dirMeta.guards || {}, |
| viewQueries: viewQueries || [], |
| entryComponents: entryComponentMetadata, |
| componentViewType: nonNormalizedTemplateMetadata ? this.getComponentViewClass(directiveType) : |
| null, |
| rendererType: nonNormalizedTemplateMetadata ? this.getRendererType(directiveType) : null, |
| componentFactory: null |
| }); |
| if (nonNormalizedTemplateMetadata) { |
| metadata.componentFactory = |
| this.getComponentFactory(selector, directiveType, metadata.inputs, metadata.outputs); |
| } |
| cacheEntry = { metadata: metadata, annotation: dirMeta }; |
| this._nonNormalizedDirectiveCache.set(directiveType, cacheEntry); |
| return cacheEntry; |
| }; |
| /** |
| * Gets the metadata for the given directive. |
| * This assumes `loadNgModuleDirectiveAndPipeMetadata` has been called first. |
| */ |
| CompileMetadataResolver.prototype.getDirectiveMetadata = function (directiveType) { |
| var dirMeta = this._directiveCache.get(directiveType); |
| if (!dirMeta) { |
| this._reportError(syntaxError("Illegal state: getDirectiveMetadata can only be called after loadNgModuleDirectiveAndPipeMetadata for a module that declares it. Directive " + stringifyType(directiveType) + "."), directiveType); |
| } |
| return dirMeta; |
| }; |
| CompileMetadataResolver.prototype.getDirectiveSummary = function (dirType) { |
| var dirSummary = this._loadSummary(dirType, exports.CompileSummaryKind.Directive); |
| if (!dirSummary) { |
| this._reportError(syntaxError("Illegal state: Could not load the summary for directive " + stringifyType(dirType) + "."), dirType); |
| } |
| return dirSummary; |
| }; |
| CompileMetadataResolver.prototype.isDirective = function (type) { |
| return !!this._loadSummary(type, exports.CompileSummaryKind.Directive) || |
| this._directiveResolver.isDirective(type); |
| }; |
| CompileMetadataResolver.prototype.isPipe = function (type) { |
| return !!this._loadSummary(type, exports.CompileSummaryKind.Pipe) || |
| this._pipeResolver.isPipe(type); |
| }; |
| CompileMetadataResolver.prototype.isNgModule = function (type) { |
| return !!this._loadSummary(type, exports.CompileSummaryKind.NgModule) || |
| this._ngModuleResolver.isNgModule(type); |
| }; |
| CompileMetadataResolver.prototype.getNgModuleSummary = function (moduleType, alreadyCollecting) { |
| if (alreadyCollecting === void 0) { alreadyCollecting = null; } |
| var moduleSummary = this._loadSummary(moduleType, exports.CompileSummaryKind.NgModule); |
| if (!moduleSummary) { |
| var moduleMeta = this.getNgModuleMetadata(moduleType, false, alreadyCollecting); |
| moduleSummary = moduleMeta ? moduleMeta.toSummary() : null; |
| if (moduleSummary) { |
| this._summaryCache.set(moduleType, moduleSummary); |
| } |
| } |
| return moduleSummary; |
| }; |
| /** |
| * Loads the declared directives and pipes of an NgModule. |
| */ |
| CompileMetadataResolver.prototype.loadNgModuleDirectiveAndPipeMetadata = function (moduleType, isSync, throwIfNotFound) { |
| var _this = this; |
| if (throwIfNotFound === void 0) { throwIfNotFound = true; } |
| var ngModule = this.getNgModuleMetadata(moduleType, throwIfNotFound); |
| var loading = []; |
| if (ngModule) { |
| ngModule.declaredDirectives.forEach(function (id) { |
| var promise = _this.loadDirectiveMetadata(moduleType, id.reference, isSync); |
| if (promise) { |
| loading.push(promise); |
| } |
| }); |
| ngModule.declaredPipes.forEach(function (id) { return _this._loadPipeMetadata(id.reference); }); |
| } |
| return Promise.all(loading); |
| }; |
| CompileMetadataResolver.prototype.getShallowModuleMetadata = function (moduleType) { |
| var compileMeta = this._shallowModuleCache.get(moduleType); |
| if (compileMeta) { |
| return compileMeta; |
| } |
| var ngModuleMeta = findLast(this._reflector.shallowAnnotations(moduleType), createNgModule.isTypeOf); |
| compileMeta = { |
| type: this._getTypeMetadata(moduleType), |
| rawExports: ngModuleMeta.exports, |
| rawImports: ngModuleMeta.imports, |
| rawProviders: ngModuleMeta.providers, |
| }; |
| this._shallowModuleCache.set(moduleType, compileMeta); |
| return compileMeta; |
| }; |
| CompileMetadataResolver.prototype.getNgModuleMetadata = function (moduleType, throwIfNotFound, alreadyCollecting) { |
| var _this = this; |
| if (throwIfNotFound === void 0) { throwIfNotFound = true; } |
| if (alreadyCollecting === void 0) { alreadyCollecting = null; } |
| moduleType = resolveForwardRef(moduleType); |
| var compileMeta = this._ngModuleCache.get(moduleType); |
| if (compileMeta) { |
| return compileMeta; |
| } |
| var meta = this._ngModuleResolver.resolve(moduleType, throwIfNotFound); |
| if (!meta) { |
| return null; |
| } |
| var declaredDirectives = []; |
| var exportedNonModuleIdentifiers = []; |
| var declaredPipes = []; |
| var importedModules = []; |
| var exportedModules = []; |
| var providers = []; |
| var entryComponents = []; |
| var bootstrapComponents = []; |
| var schemas = []; |
| if (meta.imports) { |
| flattenAndDedupeArray(meta.imports).forEach(function (importedType) { |
| var importedModuleType = undefined; |
| if (isValidType(importedType)) { |
| importedModuleType = importedType; |
| } |
| else if (importedType && importedType.ngModule) { |
| var moduleWithProviders = importedType; |
| importedModuleType = moduleWithProviders.ngModule; |
| if (moduleWithProviders.providers) { |
| providers.push.apply(providers, __spread(_this._getProvidersMetadata(moduleWithProviders.providers, entryComponents, "provider for the NgModule '" + stringifyType(importedModuleType) + "'", [], importedType))); |
| } |
| } |
| if (importedModuleType) { |
| if (_this._checkSelfImport(moduleType, importedModuleType)) |
| return; |
| if (!alreadyCollecting) |
| alreadyCollecting = new Set(); |
| if (alreadyCollecting.has(importedModuleType)) { |
| _this._reportError(syntaxError(_this._getTypeDescriptor(importedModuleType) + " '" + stringifyType(importedType) + "' is imported recursively by the module '" + stringifyType(moduleType) + "'."), moduleType); |
| return; |
| } |
| alreadyCollecting.add(importedModuleType); |
| var importedModuleSummary = _this.getNgModuleSummary(importedModuleType, alreadyCollecting); |
| alreadyCollecting.delete(importedModuleType); |
| if (!importedModuleSummary) { |
| _this._reportError(syntaxError("Unexpected " + _this._getTypeDescriptor(importedType) + " '" + stringifyType(importedType) + "' imported by the module '" + stringifyType(moduleType) + "'. Please add a @NgModule annotation."), moduleType); |
| return; |
| } |
| importedModules.push(importedModuleSummary); |
| } |
| else { |
| _this._reportError(syntaxError("Unexpected value '" + stringifyType(importedType) + "' imported by the module '" + stringifyType(moduleType) + "'"), moduleType); |
| return; |
| } |
| }); |
| } |
| if (meta.exports) { |
| flattenAndDedupeArray(meta.exports).forEach(function (exportedType) { |
| if (!isValidType(exportedType)) { |
| _this._reportError(syntaxError("Unexpected value '" + stringifyType(exportedType) + "' exported by the module '" + stringifyType(moduleType) + "'"), moduleType); |
| return; |
| } |
| if (!alreadyCollecting) |
| alreadyCollecting = new Set(); |
| if (alreadyCollecting.has(exportedType)) { |
| _this._reportError(syntaxError(_this._getTypeDescriptor(exportedType) + " '" + stringify(exportedType) + "' is exported recursively by the module '" + stringifyType(moduleType) + "'"), moduleType); |
| return; |
| } |
| alreadyCollecting.add(exportedType); |
| var exportedModuleSummary = _this.getNgModuleSummary(exportedType, alreadyCollecting); |
| alreadyCollecting.delete(exportedType); |
| if (exportedModuleSummary) { |
| exportedModules.push(exportedModuleSummary); |
| } |
| else { |
| exportedNonModuleIdentifiers.push(_this._getIdentifierMetadata(exportedType)); |
| } |
| }); |
| } |
| // Note: This will be modified later, so we rely on |
| // getting a new instance every time! |
| var transitiveModule = this._getTransitiveNgModuleMetadata(importedModules, exportedModules); |
| if (meta.declarations) { |
| flattenAndDedupeArray(meta.declarations).forEach(function (declaredType) { |
| if (!isValidType(declaredType)) { |
| _this._reportError(syntaxError("Unexpected value '" + stringifyType(declaredType) + "' declared by the module '" + stringifyType(moduleType) + "'"), moduleType); |
| return; |
| } |
| var declaredIdentifier = _this._getIdentifierMetadata(declaredType); |
| if (_this.isDirective(declaredType)) { |
| transitiveModule.addDirective(declaredIdentifier); |
| declaredDirectives.push(declaredIdentifier); |
| _this._addTypeToModule(declaredType, moduleType); |
| } |
| else if (_this.isPipe(declaredType)) { |
| transitiveModule.addPipe(declaredIdentifier); |
| transitiveModule.pipes.push(declaredIdentifier); |
| declaredPipes.push(declaredIdentifier); |
| _this._addTypeToModule(declaredType, moduleType); |
| } |
| else { |
| _this._reportError(syntaxError("Unexpected " + _this._getTypeDescriptor(declaredType) + " '" + stringifyType(declaredType) + "' declared by the module '" + stringifyType(moduleType) + "'. Please add a @Pipe/@Directive/@Component annotation."), moduleType); |
| return; |
| } |
| }); |
| } |
| var exportedDirectives = []; |
| var exportedPipes = []; |
| exportedNonModuleIdentifiers.forEach(function (exportedId) { |
| if (transitiveModule.directivesSet.has(exportedId.reference)) { |
| exportedDirectives.push(exportedId); |
| transitiveModule.addExportedDirective(exportedId); |
| } |
| else if (transitiveModule.pipesSet.has(exportedId.reference)) { |
| exportedPipes.push(exportedId); |
| transitiveModule.addExportedPipe(exportedId); |
| } |
| else { |
| _this._reportError(syntaxError("Can't export " + _this._getTypeDescriptor(exportedId.reference) + " " + stringifyType(exportedId.reference) + " from " + stringifyType(moduleType) + " as it was neither declared nor imported!"), moduleType); |
| return; |
| } |
| }); |
| // The providers of the module have to go last |
| // so that they overwrite any other provider we already added. |
| if (meta.providers) { |
| providers.push.apply(providers, __spread(this._getProvidersMetadata(meta.providers, entryComponents, "provider for the NgModule '" + stringifyType(moduleType) + "'", [], moduleType))); |
| } |
| if (meta.entryComponents) { |
| entryComponents.push.apply(entryComponents, __spread(flattenAndDedupeArray(meta.entryComponents) |
| .map(function (type) { return _this._getEntryComponentMetadata(type); }))); |
| } |
| if (meta.bootstrap) { |
| flattenAndDedupeArray(meta.bootstrap).forEach(function (type) { |
| if (!isValidType(type)) { |
| _this._reportError(syntaxError("Unexpected value '" + stringifyType(type) + "' used in the bootstrap property of module '" + stringifyType(moduleType) + "'"), moduleType); |
| return; |
| } |
| bootstrapComponents.push(_this._getIdentifierMetadata(type)); |
| }); |
| } |
| entryComponents.push.apply(entryComponents, __spread(bootstrapComponents.map(function (type) { return _this._getEntryComponentMetadata(type.reference); }))); |
| if (meta.schemas) { |
| schemas.push.apply(schemas, __spread(flattenAndDedupeArray(meta.schemas))); |
| } |
| compileMeta = new CompileNgModuleMetadata({ |
| type: this._getTypeMetadata(moduleType), |
| providers: providers, |
| entryComponents: entryComponents, |
| bootstrapComponents: bootstrapComponents, |
| schemas: schemas, |
| declaredDirectives: declaredDirectives, |
| exportedDirectives: exportedDirectives, |
| declaredPipes: declaredPipes, |
| exportedPipes: exportedPipes, |
| importedModules: importedModules, |
| exportedModules: exportedModules, |
| transitiveModule: transitiveModule, |
| id: meta.id || null, |
| }); |
| entryComponents.forEach(function (id) { return transitiveModule.addEntryComponent(id); }); |
| providers.forEach(function (provider) { return transitiveModule.addProvider(provider, compileMeta.type); }); |
| transitiveModule.addModule(compileMeta.type); |
| this._ngModuleCache.set(moduleType, compileMeta); |
| return compileMeta; |
| }; |
| CompileMetadataResolver.prototype._checkSelfImport = function (moduleType, importedModuleType) { |
| if (moduleType === importedModuleType) { |
| this._reportError(syntaxError("'" + stringifyType(moduleType) + "' module can't import itself"), moduleType); |
| return true; |
| } |
| return false; |
| }; |
| CompileMetadataResolver.prototype._getTypeDescriptor = function (type) { |
| if (isValidType(type)) { |
| if (this.isDirective(type)) { |
| return 'directive'; |
| } |
| if (this.isPipe(type)) { |
| return 'pipe'; |
| } |
| if (this.isNgModule(type)) { |
| return 'module'; |
| } |
| } |
| if (type.provide) { |
| return 'provider'; |
| } |
| return 'value'; |
| }; |
| CompileMetadataResolver.prototype._addTypeToModule = function (type, moduleType) { |
| var oldModule = this._ngModuleOfTypes.get(type); |
| if (oldModule && oldModule !== moduleType) { |
| this._reportError(syntaxError("Type " + stringifyType(type) + " is part of the declarations of 2 modules: " + stringifyType(oldModule) + " and " + stringifyType(moduleType) + "! " + |
| ("Please consider moving " + stringifyType(type) + " to a higher module that imports " + stringifyType(oldModule) + " and " + stringifyType(moduleType) + ". ") + |
| ("You can also create a new NgModule that exports and includes " + stringifyType(type) + " then import that NgModule in " + stringifyType(oldModule) + " and " + stringifyType(moduleType) + ".")), moduleType); |
| return; |
| } |
| this._ngModuleOfTypes.set(type, moduleType); |
| }; |
| CompileMetadataResolver.prototype._getTransitiveNgModuleMetadata = function (importedModules, exportedModules) { |
| // collect `providers` / `entryComponents` from all imported and all exported modules |
| var result = new TransitiveCompileNgModuleMetadata(); |
| var modulesByToken = new Map(); |
| importedModules.concat(exportedModules).forEach(function (modSummary) { |
| modSummary.modules.forEach(function (mod) { return result.addModule(mod); }); |
| modSummary.entryComponents.forEach(function (comp) { return result.addEntryComponent(comp); }); |
| var addedTokens = new Set(); |
| modSummary.providers.forEach(function (entry) { |
| var tokenRef = tokenReference(entry.provider.token); |
| var prevModules = modulesByToken.get(tokenRef); |
| if (!prevModules) { |
| prevModules = new Set(); |
| modulesByToken.set(tokenRef, prevModules); |
| } |
| var moduleRef = entry.module.reference; |
| // Note: the providers of one module may still contain multiple providers |
| // per token (e.g. for multi providers), and we need to preserve these. |
| if (addedTokens.has(tokenRef) || !prevModules.has(moduleRef)) { |
| prevModules.add(moduleRef); |
| addedTokens.add(tokenRef); |
| result.addProvider(entry.provider, entry.module); |
| } |
| }); |
| }); |
| exportedModules.forEach(function (modSummary) { |
| modSummary.exportedDirectives.forEach(function (id) { return result.addExportedDirective(id); }); |
| modSummary.exportedPipes.forEach(function (id) { return result.addExportedPipe(id); }); |
| }); |
| importedModules.forEach(function (modSummary) { |
| modSummary.exportedDirectives.forEach(function (id) { return result.addDirective(id); }); |
| modSummary.exportedPipes.forEach(function (id) { return result.addPipe(id); }); |
| }); |
| return result; |
| }; |
| CompileMetadataResolver.prototype._getIdentifierMetadata = function (type) { |
| type = resolveForwardRef(type); |
| return { reference: type }; |
| }; |
| CompileMetadataResolver.prototype.isInjectable = function (type) { |
| var annotations = this._reflector.tryAnnotations(type); |
| return annotations.some(function (ann) { return createInjectable.isTypeOf(ann); }); |
| }; |
| CompileMetadataResolver.prototype.getInjectableSummary = function (type) { |
| return { |
| summaryKind: exports.CompileSummaryKind.Injectable, |
| type: this._getTypeMetadata(type, null, false) |
| }; |
| }; |
| CompileMetadataResolver.prototype.getInjectableMetadata = function (type, dependencies, throwOnUnknownDeps) { |
| if (dependencies === void 0) { dependencies = null; } |
| if (throwOnUnknownDeps === void 0) { throwOnUnknownDeps = true; } |
| var typeSummary = this._loadSummary(type, exports.CompileSummaryKind.Injectable); |
| var typeMetadata = typeSummary ? |
| typeSummary.type : |
| this._getTypeMetadata(type, dependencies, throwOnUnknownDeps); |
| var annotations = this._reflector.annotations(type).filter(function (ann) { return createInjectable.isTypeOf(ann); }); |
| if (annotations.length === 0) { |
| return null; |
| } |
| var meta = annotations[annotations.length - 1]; |
| return { |
| symbol: type, |
| type: typeMetadata, |
| providedIn: meta.providedIn, |
| useValue: meta.useValue, |
| useClass: meta.useClass, |
| useExisting: meta.useExisting, |
| useFactory: meta.useFactory, |
| deps: meta.deps, |
| }; |
| }; |
| CompileMetadataResolver.prototype._getTypeMetadata = function (type, dependencies, throwOnUnknownDeps) { |
| if (dependencies === void 0) { dependencies = null; } |
| if (throwOnUnknownDeps === void 0) { throwOnUnknownDeps = true; } |
| var identifier = this._getIdentifierMetadata(type); |
| return { |
| reference: identifier.reference, |
| diDeps: this._getDependenciesMetadata(identifier.reference, dependencies, throwOnUnknownDeps), |
| lifecycleHooks: getAllLifecycleHooks(this._reflector, identifier.reference), |
| }; |
| }; |
| CompileMetadataResolver.prototype._getFactoryMetadata = function (factory, dependencies) { |
| if (dependencies === void 0) { dependencies = null; } |
| factory = resolveForwardRef(factory); |
| return { reference: factory, diDeps: this._getDependenciesMetadata(factory, dependencies) }; |
| }; |
| /** |
| * Gets the metadata for the given pipe. |
| * This assumes `loadNgModuleDirectiveAndPipeMetadata` has been called first. |
| */ |
| CompileMetadataResolver.prototype.getPipeMetadata = function (pipeType) { |
| var pipeMeta = this._pipeCache.get(pipeType); |
| if (!pipeMeta) { |
| this._reportError(syntaxError("Illegal state: getPipeMetadata can only be called after loadNgModuleDirectiveAndPipeMetadata for a module that declares it. Pipe " + stringifyType(pipeType) + "."), pipeType); |
| } |
| return pipeMeta || null; |
| }; |
| CompileMetadataResolver.prototype.getPipeSummary = function (pipeType) { |
| var pipeSummary = this._loadSummary(pipeType, exports.CompileSummaryKind.Pipe); |
| if (!pipeSummary) { |
| this._reportError(syntaxError("Illegal state: Could not load the summary for pipe " + stringifyType(pipeType) + "."), pipeType); |
| } |
| return pipeSummary; |
| }; |
| CompileMetadataResolver.prototype.getOrLoadPipeMetadata = function (pipeType) { |
| var pipeMeta = this._pipeCache.get(pipeType); |
| if (!pipeMeta) { |
| pipeMeta = this._loadPipeMetadata(pipeType); |
| } |
| return pipeMeta; |
| }; |
| CompileMetadataResolver.prototype._loadPipeMetadata = function (pipeType) { |
| pipeType = resolveForwardRef(pipeType); |
| var pipeAnnotation = this._pipeResolver.resolve(pipeType); |
| var pipeMeta = new CompilePipeMetadata({ |
| type: this._getTypeMetadata(pipeType), |
| name: pipeAnnotation.name, |
| pure: !!pipeAnnotation.pure |
| }); |
| this._pipeCache.set(pipeType, pipeMeta); |
| this._summaryCache.set(pipeType, pipeMeta.toSummary()); |
| return pipeMeta; |
| }; |
| CompileMetadataResolver.prototype._getDependenciesMetadata = function (typeOrFunc, dependencies, throwOnUnknownDeps) { |
| var _this = this; |
| if (throwOnUnknownDeps === void 0) { throwOnUnknownDeps = true; } |
| var hasUnknownDeps = false; |
| var params = dependencies || this._reflector.parameters(typeOrFunc) || []; |
| var dependenciesMetadata = params.map(function (param) { |
| var isAttribute = false; |
| var isHost = false; |
| var isSelf = false; |
| var isSkipSelf = false; |
| var isOptional = false; |
| var token = null; |
| if (Array.isArray(param)) { |
| param.forEach(function (paramEntry) { |
| if (createHost.isTypeOf(paramEntry)) { |
| isHost = true; |
| } |
| else if (createSelf.isTypeOf(paramEntry)) { |
| isSelf = true; |
| } |
| else if (createSkipSelf.isTypeOf(paramEntry)) { |
| isSkipSelf = true; |
| } |
| else if (createOptional.isTypeOf(paramEntry)) { |
| isOptional = true; |
| } |
| else if (createAttribute.isTypeOf(paramEntry)) { |
| isAttribute = true; |
| token = paramEntry.attributeName; |
| } |
| else if (createInject.isTypeOf(paramEntry)) { |
| token = paramEntry.token; |
| } |
| else if (createInjectionToken.isTypeOf(paramEntry) || |
| paramEntry instanceof StaticSymbol) { |
| token = paramEntry; |
| } |
| else if (isValidType(paramEntry) && token == null) { |
| token = paramEntry; |
| } |
| }); |
| } |
| else { |
| token = param; |
| } |
| if (token == null) { |
| hasUnknownDeps = true; |
| return {}; |
| } |
| return { |
| isAttribute: isAttribute, |
| isHost: isHost, |
| isSelf: isSelf, |
| isSkipSelf: isSkipSelf, |
| isOptional: isOptional, |
| token: _this._getTokenMetadata(token) |
| }; |
| }); |
| if (hasUnknownDeps) { |
| var depsTokens = dependenciesMetadata.map(function (dep) { return dep.token ? stringifyType(dep.token) : '?'; }).join(', '); |
| var message = "Can't resolve all parameters for " + stringifyType(typeOrFunc) + ": (" + depsTokens + ")."; |
| if (throwOnUnknownDeps || this._config.strictInjectionParameters) { |
| this._reportError(syntaxError(message), typeOrFunc); |
| } |
| else { |
| this._console.warn("Warning: " + message + " This will become an error in Angular v6.x"); |
| } |
| } |
| return dependenciesMetadata; |
| }; |
| CompileMetadataResolver.prototype._getTokenMetadata = function (token) { |
| token = resolveForwardRef(token); |
| var compileToken; |
| if (typeof token === 'string') { |
| compileToken = { value: token }; |
| } |
| else { |
| compileToken = { identifier: { reference: token } }; |
| } |
| return compileToken; |
| }; |
| CompileMetadataResolver.prototype._getProvidersMetadata = function (providers, targetEntryComponents, debugInfo, compileProviders, type) { |
| var _this = this; |
| if (compileProviders === void 0) { compileProviders = []; } |
| providers.forEach(function (provider, providerIdx) { |
| if (Array.isArray(provider)) { |
| _this._getProvidersMetadata(provider, targetEntryComponents, debugInfo, compileProviders); |
| } |
| else { |
| provider = resolveForwardRef(provider); |
| var providerMeta = undefined; |
| if (provider && typeof provider === 'object' && provider.hasOwnProperty('provide')) { |
| _this._validateProvider(provider); |
| providerMeta = new ProviderMeta(provider.provide, provider); |
| } |
| else if (isValidType(provider)) { |
| providerMeta = new ProviderMeta(provider, { useClass: provider }); |
| } |
| else if (provider === void 0) { |
| _this._reportError(syntaxError("Encountered undefined provider! Usually this means you have a circular dependencies. This might be caused by using 'barrel' index.ts files.")); |
| return; |
| } |
| else { |
| var providersInfo = providers.reduce(function (soFar, seenProvider, seenProviderIdx) { |
| if (seenProviderIdx < providerIdx) { |
| soFar.push("" + stringifyType(seenProvider)); |
| } |
| else if (seenProviderIdx == providerIdx) { |
| soFar.push("?" + stringifyType(seenProvider) + "?"); |
| } |
| else if (seenProviderIdx == providerIdx + 1) { |
| soFar.push('...'); |
| } |
| return soFar; |
| }, []) |
| .join(', '); |
| _this._reportError(syntaxError("Invalid " + (debugInfo ? debugInfo : 'provider') + " - only instances of Provider and Type are allowed, got: [" + providersInfo + "]"), type); |
| return; |
| } |
| if (providerMeta.token === |
| _this._reflector.resolveExternalReference(Identifiers.ANALYZE_FOR_ENTRY_COMPONENTS)) { |
| targetEntryComponents.push.apply(targetEntryComponents, __spread(_this._getEntryComponentsFromProvider(providerMeta, type))); |
| } |
| else { |
| compileProviders.push(_this.getProviderMetadata(providerMeta)); |
| } |
| } |
| }); |
| return compileProviders; |
| }; |
| CompileMetadataResolver.prototype._validateProvider = function (provider) { |
| if (provider.hasOwnProperty('useClass') && provider.useClass == null) { |
| this._reportError(syntaxError("Invalid provider for " + stringifyType(provider.provide) + ". useClass cannot be " + provider.useClass + ".\n Usually it happens when:\n 1. There's a circular dependency (might be caused by using index.ts (barrel) files).\n 2. Class was used before it was declared. Use forwardRef in this case.")); |
| } |
| }; |
| CompileMetadataResolver.prototype._getEntryComponentsFromProvider = function (provider, type) { |
| var _this = this; |
| var components = []; |
| var collectedIdentifiers = []; |
| if (provider.useFactory || provider.useExisting || provider.useClass) { |
| this._reportError(syntaxError("The ANALYZE_FOR_ENTRY_COMPONENTS token only supports useValue!"), type); |
| return []; |
| } |
| if (!provider.multi) { |
| this._reportError(syntaxError("The ANALYZE_FOR_ENTRY_COMPONENTS token only supports 'multi = true'!"), type); |
| return []; |
| } |
| extractIdentifiers(provider.useValue, collectedIdentifiers); |
| collectedIdentifiers.forEach(function (identifier) { |
| var entry = _this._getEntryComponentMetadata(identifier.reference, false); |
| if (entry) { |
| components.push(entry); |
| } |
| }); |
| return components; |
| }; |
| CompileMetadataResolver.prototype._getEntryComponentMetadata = function (dirType, throwIfNotFound) { |
| if (throwIfNotFound === void 0) { throwIfNotFound = true; } |
| var dirMeta = this.getNonNormalizedDirectiveMetadata(dirType); |
| if (dirMeta && dirMeta.metadata.isComponent) { |
| return { componentType: dirType, componentFactory: dirMeta.metadata.componentFactory }; |
| } |
| var dirSummary = this._loadSummary(dirType, exports.CompileSummaryKind.Directive); |
| if (dirSummary && dirSummary.isComponent) { |
| return { componentType: dirType, componentFactory: dirSummary.componentFactory }; |
| } |
| if (throwIfNotFound) { |
| throw syntaxError(dirType.name + " cannot be used as an entry component."); |
| } |
| return null; |
| }; |
| CompileMetadataResolver.prototype._getInjectableTypeMetadata = function (type, dependencies) { |
| if (dependencies === void 0) { dependencies = null; } |
| var typeSummary = this._loadSummary(type, exports.CompileSummaryKind.Injectable); |
| if (typeSummary) { |
| return typeSummary.type; |
| } |
| return this._getTypeMetadata(type, dependencies); |
| }; |
| CompileMetadataResolver.prototype.getProviderMetadata = function (provider) { |
| var compileDeps = undefined; |
| var compileTypeMetadata = null; |
| var compileFactoryMetadata = null; |
| var token = this._getTokenMetadata(provider.token); |
| if (provider.useClass) { |
| compileTypeMetadata = |
| this._getInjectableTypeMetadata(provider.useClass, provider.dependencies); |
| compileDeps = compileTypeMetadata.diDeps; |
| if (provider.token === provider.useClass) { |
| // use the compileTypeMetadata as it contains information about lifecycleHooks... |
| token = { identifier: compileTypeMetadata }; |
| } |
| } |
| else if (provider.useFactory) { |
| compileFactoryMetadata = this._getFactoryMetadata(provider.useFactory, provider.dependencies); |
| compileDeps = compileFactoryMetadata.diDeps; |
| } |
| return { |
| token: token, |
| useClass: compileTypeMetadata, |
| useValue: provider.useValue, |
| useFactory: compileFactoryMetadata, |
| useExisting: provider.useExisting ? this._getTokenMetadata(provider.useExisting) : undefined, |
| deps: compileDeps, |
| multi: provider.multi |
| }; |
| }; |
| CompileMetadataResolver.prototype._getQueriesMetadata = function (queries, isViewQuery, directiveType) { |
| var _this = this; |
| var res = []; |
| Object.keys(queries).forEach(function (propertyName) { |
| var query = queries[propertyName]; |
| if (query.isViewQuery === isViewQuery) { |
| res.push(_this._getQueryMetadata(query, propertyName, directiveType)); |
| } |
| }); |
| return res; |
| }; |
| CompileMetadataResolver.prototype._queryVarBindings = function (selector) { return selector.split(/\s*,\s*/); }; |
| CompileMetadataResolver.prototype._getQueryMetadata = function (q, propertyName, typeOrFunc) { |
| var _this = this; |
| var selectors; |
| if (typeof q.selector === 'string') { |
| selectors = |
| this._queryVarBindings(q.selector).map(function (varName) { return _this._getTokenMetadata(varName); }); |
| } |
| else { |
| if (!q.selector) { |
| this._reportError(syntaxError("Can't construct a query for the property \"" + propertyName + "\" of \"" + stringifyType(typeOrFunc) + "\" since the query selector wasn't defined."), typeOrFunc); |
| selectors = []; |
| } |
| else { |
| selectors = [this._getTokenMetadata(q.selector)]; |
| } |
| } |
| return { |
| selectors: selectors, |
| first: q.first, |
| descendants: q.descendants, propertyName: propertyName, |
| read: q.read ? this._getTokenMetadata(q.read) : null, |
| static: q.static |
| }; |
| }; |
| CompileMetadataResolver.prototype._reportError = function (error, type, otherType) { |
| if (this._errorCollector) { |
| this._errorCollector(error, type); |
| if (otherType) { |
| this._errorCollector(error, otherType); |
| } |
| } |
| else { |
| throw error; |
| } |
| }; |
| return CompileMetadataResolver; |
| }()); |
| function flattenArray(tree, out) { |
| if (out === void 0) { out = []; } |
| if (tree) { |
| for (var i = 0; i < tree.length; i++) { |
| var item = resolveForwardRef(tree[i]); |
| if (Array.isArray(item)) { |
| flattenArray(item, out); |
| } |
| else { |
| out.push(item); |
| } |
| } |
| } |
| return out; |
| } |
| function dedupeArray(array) { |
| if (array) { |
| return Array.from(new Set(array)); |
| } |
| return []; |
| } |
| function flattenAndDedupeArray(tree) { |
| return dedupeArray(flattenArray(tree)); |
| } |
| function isValidType(value) { |
| return (value instanceof StaticSymbol) || (value instanceof Type); |
| } |
| function extractIdentifiers(value, targetIdentifiers) { |
| visitValue(value, new _CompileValueConverter(), targetIdentifiers); |
| } |
| var _CompileValueConverter = /** @class */ (function (_super) { |
| __extends(_CompileValueConverter, _super); |
| function _CompileValueConverter() { |
| return _super !== null && _super.apply(this, arguments) || this; |
| } |
| _CompileValueConverter.prototype.visitOther = function (value, targetIdentifiers) { |
| targetIdentifiers.push({ reference: value }); |
| }; |
| return _CompileValueConverter; |
| }(ValueTransformer)); |
| function stringifyType(type) { |
| if (type instanceof StaticSymbol) { |
| return type.name + " in " + type.filePath; |
| } |
| else { |
| return stringify(type); |
| } |
| } |
| /** |
| * Indicates that a component is still being loaded in a synchronous compile. |
| */ |
| function componentStillLoadingError(compType) { |
| var error = Error("Can't compile synchronously as " + stringify(compType) + " is still being loaded!"); |
| error[ERROR_COMPONENT_TYPE] = compType; |
| return error; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| function providerDef(ctx, providerAst) { |
| var flags = 0 /* None */; |
| if (!providerAst.eager) { |
| flags |= 4096 /* LazyProvider */; |
| } |
| if (providerAst.providerType === exports.ProviderAstType.PrivateService) { |
| flags |= 8192 /* PrivateProvider */; |
| } |
| if (providerAst.isModule) { |
| flags |= 1073741824 /* TypeModuleProvider */; |
| } |
| providerAst.lifecycleHooks.forEach(function (lifecycleHook) { |
| // for regular providers, we only support ngOnDestroy |
| if (lifecycleHook === LifecycleHooks.OnDestroy || |
| providerAst.providerType === exports.ProviderAstType.Directive || |
| providerAst.providerType === exports.ProviderAstType.Component) { |
| flags |= lifecycleHookToNodeFlag(lifecycleHook); |
| } |
| }); |
| var _a = providerAst.multiProvider ? |
| multiProviderDef(ctx, flags, providerAst.providers) : |
| singleProviderDef(ctx, flags, providerAst.providerType, providerAst.providers[0]), providerExpr = _a.providerExpr, providerFlags = _a.flags, depsExpr = _a.depsExpr; |
| return { |
| providerExpr: providerExpr, |
| flags: providerFlags, depsExpr: depsExpr, |
| tokenExpr: tokenExpr(ctx, providerAst.token), |
| }; |
| } |
| function multiProviderDef(ctx, flags, providers) { |
| var allDepDefs = []; |
| var allParams = []; |
| var exprs = providers.map(function (provider, providerIndex) { |
| var expr; |
| if (provider.useClass) { |
| var depExprs = convertDeps(providerIndex, provider.deps || provider.useClass.diDeps); |
| expr = ctx.importExpr(provider.useClass.reference).instantiate(depExprs); |
| } |
| else if (provider.useFactory) { |
| var depExprs = convertDeps(providerIndex, provider.deps || provider.useFactory.diDeps); |
| expr = ctx.importExpr(provider.useFactory.reference).callFn(depExprs); |
| } |
| else if (provider.useExisting) { |
| var depExprs = convertDeps(providerIndex, [{ token: provider.useExisting }]); |
| expr = depExprs[0]; |
| } |
| else { |
| expr = convertValueToOutputAst(ctx, provider.useValue); |
| } |
| return expr; |
| }); |
| var providerExpr = fn(allParams, [new ReturnStatement(literalArr(exprs))], INFERRED_TYPE); |
| return { |
| providerExpr: providerExpr, |
| flags: flags | 1024 /* TypeFactoryProvider */, |
| depsExpr: literalArr(allDepDefs) |
| }; |
| function convertDeps(providerIndex, deps) { |
| return deps.map(function (dep, depIndex) { |
| var paramName = "p" + providerIndex + "_" + depIndex; |
| allParams.push(new FnParam(paramName, DYNAMIC_TYPE)); |
| allDepDefs.push(depDef(ctx, dep)); |
| return variable(paramName); |
| }); |
| } |
| } |
| function singleProviderDef(ctx, flags, providerType, providerMeta) { |
| var providerExpr; |
| var deps; |
| if (providerType === exports.ProviderAstType.Directive || providerType === exports.ProviderAstType.Component) { |
| providerExpr = ctx.importExpr(providerMeta.useClass.reference); |
| flags |= 16384 /* TypeDirective */; |
| deps = providerMeta.deps || providerMeta.useClass.diDeps; |
| } |
| else { |
| if (providerMeta.useClass) { |
| providerExpr = ctx.importExpr(providerMeta.useClass.reference); |
| flags |= 512 /* TypeClassProvider */; |
| deps = providerMeta.deps || providerMeta.useClass.diDeps; |
| } |
| else if (providerMeta.useFactory) { |
| providerExpr = ctx.importExpr(providerMeta.useFactory.reference); |
| flags |= 1024 /* TypeFactoryProvider */; |
| deps = providerMeta.deps || providerMeta.useFactory.diDeps; |
| } |
| else if (providerMeta.useExisting) { |
| providerExpr = NULL_EXPR; |
| flags |= 2048 /* TypeUseExistingProvider */; |
| deps = [{ token: providerMeta.useExisting }]; |
| } |
| else { |
| providerExpr = convertValueToOutputAst(ctx, providerMeta.useValue); |
| flags |= 256 /* TypeValueProvider */; |
| deps = []; |
| } |
| } |
| var depsExpr = literalArr(deps.map(function (dep) { return depDef(ctx, dep); })); |
| return { providerExpr: providerExpr, flags: flags, depsExpr: depsExpr }; |
| } |
| function tokenExpr(ctx, tokenMeta) { |
| return tokenMeta.identifier ? ctx.importExpr(tokenMeta.identifier.reference) : |
| literal(tokenMeta.value); |
| } |
| function depDef(ctx, dep) { |
| // Note: the following fields have already been normalized out by provider_analyzer: |
| // - isAttribute, isHost |
| var expr = dep.isValue ? convertValueToOutputAst(ctx, dep.value) : tokenExpr(ctx, dep.token); |
| var flags = 0 /* None */; |
| if (dep.isSkipSelf) { |
| flags |= 1 /* SkipSelf */; |
| } |
| if (dep.isOptional) { |
| flags |= 2 /* Optional */; |
| } |
| if (dep.isSelf) { |
| flags |= 4 /* Self */; |
| } |
| if (dep.isValue) { |
| flags |= 8 /* Value */; |
| } |
| return flags === 0 /* None */ ? expr : literalArr([literal(flags), expr]); |
| } |
| function lifecycleHookToNodeFlag(lifecycleHook) { |
| var nodeFlag = 0 /* None */; |
| switch (lifecycleHook) { |
| case LifecycleHooks.AfterContentChecked: |
| nodeFlag = 2097152 /* AfterContentChecked */; |
| break; |
| case LifecycleHooks.AfterContentInit: |
| nodeFlag = 1048576 /* AfterContentInit */; |
| break; |
| case LifecycleHooks.AfterViewChecked: |
| nodeFlag = 8388608 /* AfterViewChecked */; |
| break; |
| case LifecycleHooks.AfterViewInit: |
| nodeFlag = 4194304 /* AfterViewInit */; |
| break; |
| case LifecycleHooks.DoCheck: |
| nodeFlag = 262144 /* DoCheck */; |
| break; |
| case LifecycleHooks.OnChanges: |
| nodeFlag = 524288 /* OnChanges */; |
| break; |
| case LifecycleHooks.OnDestroy: |
| nodeFlag = 131072 /* OnDestroy */; |
| break; |
| case LifecycleHooks.OnInit: |
| nodeFlag = 65536 /* OnInit */; |
| break; |
| } |
| return nodeFlag; |
| } |
| function componentFactoryResolverProviderDef(reflector, ctx, flags, entryComponents) { |
| var entryComponentFactories = entryComponents.map(function (entryComponent) { return ctx.importExpr(entryComponent.componentFactory); }); |
| var token = createTokenForExternalReference(reflector, Identifiers.ComponentFactoryResolver); |
| var classMeta = { |
| diDeps: [ |
| { isValue: true, value: literalArr(entryComponentFactories) }, |
| { token: token, isSkipSelf: true, isOptional: true }, |
| { token: createTokenForExternalReference(reflector, Identifiers.NgModuleRef) }, |
| ], |
| lifecycleHooks: [], |
| reference: reflector.resolveExternalReference(Identifiers.CodegenComponentFactoryResolver) |
| }; |
| var _a = singleProviderDef(ctx, flags, exports.ProviderAstType.PrivateService, { |
| token: token, |
| multi: false, |
| useClass: classMeta, |
| }), providerExpr = _a.providerExpr, providerFlags = _a.flags, depsExpr = _a.depsExpr; |
| return { providerExpr: providerExpr, flags: providerFlags, depsExpr: depsExpr, tokenExpr: tokenExpr(ctx, token) }; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var NgModuleCompileResult = /** @class */ (function () { |
| function NgModuleCompileResult(ngModuleFactoryVar) { |
| this.ngModuleFactoryVar = ngModuleFactoryVar; |
| } |
| return NgModuleCompileResult; |
| }()); |
| var LOG_VAR = variable('_l'); |
| var NgModuleCompiler = /** @class */ (function () { |
| function NgModuleCompiler(reflector) { |
| this.reflector = reflector; |
| } |
| NgModuleCompiler.prototype.compile = function (ctx, ngModuleMeta, extraProviders) { |
| var sourceSpan = typeSourceSpan('NgModule', ngModuleMeta.type); |
| var entryComponentFactories = ngModuleMeta.transitiveModule.entryComponents; |
| var bootstrapComponents = ngModuleMeta.bootstrapComponents; |
| var providerParser = new NgModuleProviderAnalyzer(this.reflector, ngModuleMeta, extraProviders, sourceSpan); |
| var providerDefs = [componentFactoryResolverProviderDef(this.reflector, ctx, 0 /* None */, entryComponentFactories)] |
| .concat(providerParser.parse().map(function (provider) { return providerDef(ctx, provider); })) |
| .map(function (_a) { |
| var providerExpr = _a.providerExpr, depsExpr = _a.depsExpr, flags = _a.flags, tokenExpr = _a.tokenExpr; |
| return importExpr(Identifiers.moduleProviderDef).callFn([ |
| literal(flags), tokenExpr, providerExpr, depsExpr |
| ]); |
| }); |
| var ngModuleDef = importExpr(Identifiers.moduleDef).callFn([literalArr(providerDefs)]); |
| var ngModuleDefFactory = fn([new FnParam(LOG_VAR.name)], [new ReturnStatement(ngModuleDef)], INFERRED_TYPE); |
| var ngModuleFactoryVar = identifierName(ngModuleMeta.type) + "NgFactory"; |
| this._createNgModuleFactory(ctx, ngModuleMeta.type.reference, importExpr(Identifiers.createModuleFactory).callFn([ |
| ctx.importExpr(ngModuleMeta.type.reference), |
| literalArr(bootstrapComponents.map(function (id) { return ctx.importExpr(id.reference); })), |
| ngModuleDefFactory |
| ])); |
| if (ngModuleMeta.id) { |
| var id = typeof ngModuleMeta.id === 'string' ? literal(ngModuleMeta.id) : |
| ctx.importExpr(ngModuleMeta.id); |
| var registerFactoryStmt = importExpr(Identifiers.RegisterModuleFactoryFn) |
| .callFn([id, variable(ngModuleFactoryVar)]) |
| .toStmt(); |
| ctx.statements.push(registerFactoryStmt); |
| } |
| return new NgModuleCompileResult(ngModuleFactoryVar); |
| }; |
| NgModuleCompiler.prototype.createStub = function (ctx, ngModuleReference) { |
| this._createNgModuleFactory(ctx, ngModuleReference, NULL_EXPR); |
| }; |
| NgModuleCompiler.prototype._createNgModuleFactory = function (ctx, reference, value) { |
| var ngModuleFactoryVar = identifierName({ reference: reference }) + "NgFactory"; |
| var ngModuleFactoryStmt = variable(ngModuleFactoryVar) |
| .set(value) |
| .toDeclStmt(importType(Identifiers.NgModuleFactory, [expressionType(ctx.importExpr(reference))], [TypeModifier.Const]), [exports.StmtModifier.Final, exports.StmtModifier.Exported]); |
| ctx.statements.push(ngModuleFactoryStmt); |
| }; |
| return NgModuleCompiler; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * Resolves types to {@link NgModule}. |
| */ |
| var NgModuleResolver = /** @class */ (function () { |
| function NgModuleResolver(_reflector) { |
| this._reflector = _reflector; |
| } |
| NgModuleResolver.prototype.isNgModule = function (type) { return this._reflector.annotations(type).some(createNgModule.isTypeOf); }; |
| NgModuleResolver.prototype.resolve = function (type, throwIfNotFound) { |
| if (throwIfNotFound === void 0) { throwIfNotFound = true; } |
| var ngModuleMeta = findLast(this._reflector.annotations(type), createNgModule.isTypeOf); |
| if (ngModuleMeta) { |
| return ngModuleMeta; |
| } |
| else { |
| if (throwIfNotFound) { |
| throw new Error("No NgModule metadata found for '" + stringify(type) + "'."); |
| } |
| return null; |
| } |
| }; |
| return NgModuleResolver; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| function debugOutputAstAsTypeScript(ast) { |
| var converter = new _TsEmitterVisitor(); |
| var ctx = EmitterVisitorContext.createRoot(); |
| var asts = Array.isArray(ast) ? ast : [ast]; |
| asts.forEach(function (ast) { |
| if (ast instanceof Statement) { |
| ast.visitStatement(converter, ctx); |
| } |
| else if (ast instanceof Expression) { |
| ast.visitExpression(converter, ctx); |
| } |
| else if (ast instanceof Type$1) { |
| ast.visitType(converter, ctx); |
| } |
| else { |
| throw new Error("Don't know how to print debug info for " + ast); |
| } |
| }); |
| return ctx.toSource(); |
| } |
| var TypeScriptEmitter = /** @class */ (function () { |
| function TypeScriptEmitter() { |
| } |
| TypeScriptEmitter.prototype.emitStatementsAndContext = function (genFilePath, stmts, preamble, emitSourceMaps, referenceFilter, importFilter) { |
| if (preamble === void 0) { preamble = ''; } |
| if (emitSourceMaps === void 0) { emitSourceMaps = true; } |
| var converter = new _TsEmitterVisitor(referenceFilter, importFilter); |
| var ctx = EmitterVisitorContext.createRoot(); |
| converter.visitAllStatements(stmts, ctx); |
| var preambleLines = preamble ? preamble.split('\n') : []; |
| converter.reexports.forEach(function (reexports, exportedModuleName) { |
| var reexportsCode = reexports.map(function (reexport) { return reexport.name + " as " + reexport.as; }).join(','); |
| preambleLines.push("export {" + reexportsCode + "} from '" + exportedModuleName + "';"); |
| }); |
| converter.importsWithPrefixes.forEach(function (prefix, importedModuleName) { |
| // Note: can't write the real word for import as it screws up system.js auto detection... |
| preambleLines.push("imp" + |
| ("ort * as " + prefix + " from '" + importedModuleName + "';")); |
| }); |
| var sm = emitSourceMaps ? |
| ctx.toSourceMapGenerator(genFilePath, preambleLines.length).toJsComment() : |
| ''; |
| var lines = __spread(preambleLines, [ctx.toSource(), sm]); |
| if (sm) { |
| // always add a newline at the end, as some tools have bugs without it. |
| lines.push(''); |
| } |
| ctx.setPreambleLineCount(preambleLines.length); |
| return { sourceText: lines.join('\n'), context: ctx }; |
| }; |
| TypeScriptEmitter.prototype.emitStatements = function (genFilePath, stmts, preamble) { |
| if (preamble === void 0) { preamble = ''; } |
| return this.emitStatementsAndContext(genFilePath, stmts, preamble).sourceText; |
| }; |
| return TypeScriptEmitter; |
| }()); |
| var _TsEmitterVisitor = /** @class */ (function (_super) { |
| __extends(_TsEmitterVisitor, _super); |
| function _TsEmitterVisitor(referenceFilter, importFilter) { |
| var _this = _super.call(this, false) || this; |
| _this.referenceFilter = referenceFilter; |
| _this.importFilter = importFilter; |
| _this.typeExpression = 0; |
| _this.importsWithPrefixes = new Map(); |
| _this.reexports = new Map(); |
| return _this; |
| } |
| _TsEmitterVisitor.prototype.visitType = function (t, ctx, defaultType) { |
| if (defaultType === void 0) { defaultType = 'any'; } |
| if (t) { |
| this.typeExpression++; |
| t.visitType(this, ctx); |
| this.typeExpression--; |
| } |
| else { |
| ctx.print(null, defaultType); |
| } |
| }; |
| _TsEmitterVisitor.prototype.visitLiteralExpr = function (ast, ctx) { |
| var value = ast.value; |
| if (value == null && ast.type != INFERRED_TYPE) { |
| ctx.print(ast, "(" + value + " as any)"); |
| return null; |
| } |
| return _super.prototype.visitLiteralExpr.call(this, ast, ctx); |
| }; |
| // Temporary workaround to support strictNullCheck enabled consumers of ngc emit. |
| // In SNC mode, [] have the type never[], so we cast here to any[]. |
| // TODO: narrow the cast to a more explicit type, or use a pattern that does not |
| // start with [].concat. see https://github.com/angular/angular/pull/11846 |
| _TsEmitterVisitor.prototype.visitLiteralArrayExpr = function (ast, ctx) { |
| if (ast.entries.length === 0) { |
| ctx.print(ast, '('); |
| } |
| var result = _super.prototype.visitLiteralArrayExpr.call(this, ast, ctx); |
| if (ast.entries.length === 0) { |
| ctx.print(ast, ' as any[])'); |
| } |
| return result; |
| }; |
| _TsEmitterVisitor.prototype.visitExternalExpr = function (ast, ctx) { |
| this._visitIdentifier(ast.value, ast.typeParams, ctx); |
| return null; |
| }; |
| _TsEmitterVisitor.prototype.visitAssertNotNullExpr = function (ast, ctx) { |
| var result = _super.prototype.visitAssertNotNullExpr.call(this, ast, ctx); |
| ctx.print(ast, '!'); |
| return result; |
| }; |
| _TsEmitterVisitor.prototype.visitDeclareVarStmt = function (stmt, ctx) { |
| if (stmt.hasModifier(exports.StmtModifier.Exported) && stmt.value instanceof ExternalExpr && |
| !stmt.type) { |
| // check for a reexport |
| var _a = stmt.value.value, name_1 = _a.name, moduleName = _a.moduleName; |
| if (moduleName) { |
| var reexports = this.reexports.get(moduleName); |
| if (!reexports) { |
| reexports = []; |
| this.reexports.set(moduleName, reexports); |
| } |
| reexports.push({ name: name_1, as: stmt.name }); |
| return null; |
| } |
| } |
| if (stmt.hasModifier(exports.StmtModifier.Exported)) { |
| ctx.print(stmt, "export "); |
| } |
| if (stmt.hasModifier(exports.StmtModifier.Final)) { |
| ctx.print(stmt, "const"); |
| } |
| else { |
| ctx.print(stmt, "var"); |
| } |
| ctx.print(stmt, " " + stmt.name); |
| this._printColonType(stmt.type, ctx); |
| if (stmt.value) { |
| ctx.print(stmt, " = "); |
| stmt.value.visitExpression(this, ctx); |
| } |
| ctx.println(stmt, ";"); |
| return null; |
| }; |
| _TsEmitterVisitor.prototype.visitWrappedNodeExpr = function (ast, ctx) { |
| throw new Error('Cannot visit a WrappedNodeExpr when outputting Typescript.'); |
| }; |
| _TsEmitterVisitor.prototype.visitCastExpr = function (ast, ctx) { |
| ctx.print(ast, "(<"); |
| ast.type.visitType(this, ctx); |
| ctx.print(ast, ">"); |
| ast.value.visitExpression(this, ctx); |
| ctx.print(ast, ")"); |
| return null; |
| }; |
| _TsEmitterVisitor.prototype.visitInstantiateExpr = function (ast, ctx) { |
| ctx.print(ast, "new "); |
| this.typeExpression++; |
| ast.classExpr.visitExpression(this, ctx); |
| this.typeExpression--; |
| ctx.print(ast, "("); |
| this.visitAllExpressions(ast.args, ctx, ','); |
| ctx.print(ast, ")"); |
| return null; |
| }; |
| _TsEmitterVisitor.prototype.visitDeclareClassStmt = function (stmt, ctx) { |
| var _this = this; |
| ctx.pushClass(stmt); |
| if (stmt.hasModifier(exports.StmtModifier.Exported)) { |
| ctx.print(stmt, "export "); |
| } |
| ctx.print(stmt, "class " + stmt.name); |
| if (stmt.parent != null) { |
| ctx.print(stmt, " extends "); |
| this.typeExpression++; |
| stmt.parent.visitExpression(this, ctx); |
| this.typeExpression--; |
| } |
| ctx.println(stmt, " {"); |
| ctx.incIndent(); |
| stmt.fields.forEach(function (field) { return _this._visitClassField(field, ctx); }); |
| if (stmt.constructorMethod != null) { |
| this._visitClassConstructor(stmt, ctx); |
| } |
| stmt.getters.forEach(function (getter) { return _this._visitClassGetter(getter, ctx); }); |
| stmt.methods.forEach(function (method) { return _this._visitClassMethod(method, ctx); }); |
| ctx.decIndent(); |
| ctx.println(stmt, "}"); |
| ctx.popClass(); |
| return null; |
| }; |
| _TsEmitterVisitor.prototype._visitClassField = function (field, ctx) { |
| if (field.hasModifier(exports.StmtModifier.Private)) { |
| // comment out as a workaround for #10967 |
| ctx.print(null, "/*private*/ "); |
| } |
| if (field.hasModifier(exports.StmtModifier.Static)) { |
| ctx.print(null, 'static '); |
| } |
| ctx.print(null, field.name); |
| this._printColonType(field.type, ctx); |
| if (field.initializer) { |
| ctx.print(null, ' = '); |
| field.initializer.visitExpression(this, ctx); |
| } |
| ctx.println(null, ";"); |
| }; |
| _TsEmitterVisitor.prototype._visitClassGetter = function (getter, ctx) { |
| if (getter.hasModifier(exports.StmtModifier.Private)) { |
| ctx.print(null, "private "); |
| } |
| ctx.print(null, "get " + getter.name + "()"); |
| this._printColonType(getter.type, ctx); |
| ctx.println(null, " {"); |
| ctx.incIndent(); |
| this.visitAllStatements(getter.body, ctx); |
| ctx.decIndent(); |
| ctx.println(null, "}"); |
| }; |
| _TsEmitterVisitor.prototype._visitClassConstructor = function (stmt, ctx) { |
| ctx.print(stmt, "constructor("); |
| this._visitParams(stmt.constructorMethod.params, ctx); |
| ctx.println(stmt, ") {"); |
| ctx.incIndent(); |
| this.visitAllStatements(stmt.constructorMethod.body, ctx); |
| ctx.decIndent(); |
| ctx.println(stmt, "}"); |
| }; |
| _TsEmitterVisitor.prototype._visitClassMethod = function (method, ctx) { |
| if (method.hasModifier(exports.StmtModifier.Private)) { |
| ctx.print(null, "private "); |
| } |
| ctx.print(null, method.name + "("); |
| this._visitParams(method.params, ctx); |
| ctx.print(null, ")"); |
| this._printColonType(method.type, ctx, 'void'); |
| ctx.println(null, " {"); |
| ctx.incIndent(); |
| this.visitAllStatements(method.body, ctx); |
| ctx.decIndent(); |
| ctx.println(null, "}"); |
| }; |
| _TsEmitterVisitor.prototype.visitFunctionExpr = function (ast, ctx) { |
| if (ast.name) { |
| ctx.print(ast, 'function '); |
| ctx.print(ast, ast.name); |
| } |
| ctx.print(ast, "("); |
| this._visitParams(ast.params, ctx); |
| ctx.print(ast, ")"); |
| this._printColonType(ast.type, ctx, 'void'); |
| if (!ast.name) { |
| ctx.print(ast, " => "); |
| } |
| ctx.println(ast, '{'); |
| ctx.incIndent(); |
| this.visitAllStatements(ast.statements, ctx); |
| ctx.decIndent(); |
| ctx.print(ast, "}"); |
| return null; |
| }; |
| _TsEmitterVisitor.prototype.visitDeclareFunctionStmt = function (stmt, ctx) { |
| if (stmt.hasModifier(exports.StmtModifier.Exported)) { |
| ctx.print(stmt, "export "); |
| } |
| ctx.print(stmt, "function " + stmt.name + "("); |
| this._visitParams(stmt.params, ctx); |
| ctx.print(stmt, ")"); |
| this._printColonType(stmt.type, ctx, 'void'); |
| ctx.println(stmt, " {"); |
| ctx.incIndent(); |
| this.visitAllStatements(stmt.statements, ctx); |
| ctx.decIndent(); |
| ctx.println(stmt, "}"); |
| return null; |
| }; |
| _TsEmitterVisitor.prototype.visitTryCatchStmt = function (stmt, ctx) { |
| ctx.println(stmt, "try {"); |
| ctx.incIndent(); |
| this.visitAllStatements(stmt.bodyStmts, ctx); |
| ctx.decIndent(); |
| ctx.println(stmt, "} catch (" + CATCH_ERROR_VAR$1.name + ") {"); |
| ctx.incIndent(); |
| var catchStmts = [CATCH_STACK_VAR$1.set(CATCH_ERROR_VAR$1.prop('stack', null)).toDeclStmt(null, [ |
| exports.StmtModifier.Final |
| ])].concat(stmt.catchStmts); |
| this.visitAllStatements(catchStmts, ctx); |
| ctx.decIndent(); |
| ctx.println(stmt, "}"); |
| return null; |
| }; |
| _TsEmitterVisitor.prototype.visitBuiltinType = function (type, ctx) { |
| var typeStr; |
| switch (type.name) { |
| case exports.BuiltinTypeName.Bool: |
| typeStr = 'boolean'; |
| break; |
| case exports.BuiltinTypeName.Dynamic: |
| typeStr = 'any'; |
| break; |
| case exports.BuiltinTypeName.Function: |
| typeStr = 'Function'; |
| break; |
| case exports.BuiltinTypeName.Number: |
| typeStr = 'number'; |
| break; |
| case exports.BuiltinTypeName.Int: |
| typeStr = 'number'; |
| break; |
| case exports.BuiltinTypeName.String: |
| typeStr = 'string'; |
| break; |
| case exports.BuiltinTypeName.None: |
| typeStr = 'never'; |
| break; |
| default: |
| throw new Error("Unsupported builtin type " + type.name); |
| } |
| ctx.print(null, typeStr); |
| return null; |
| }; |
| _TsEmitterVisitor.prototype.visitExpressionType = function (ast, ctx) { |
| var _this = this; |
| ast.value.visitExpression(this, ctx); |
| if (ast.typeParams !== null) { |
| ctx.print(null, '<'); |
| this.visitAllObjects(function (type) { return _this.visitType(type, ctx); }, ast.typeParams, ctx, ','); |
| ctx.print(null, '>'); |
| } |
| return null; |
| }; |
| _TsEmitterVisitor.prototype.visitArrayType = function (type, ctx) { |
| this.visitType(type.of, ctx); |
| ctx.print(null, "[]"); |
| return null; |
| }; |
| _TsEmitterVisitor.prototype.visitMapType = function (type, ctx) { |
| ctx.print(null, "{[key: string]:"); |
| this.visitType(type.valueType, ctx); |
| ctx.print(null, "}"); |
| return null; |
| }; |
| _TsEmitterVisitor.prototype.getBuiltinMethodName = function (method) { |
| var name; |
| switch (method) { |
| case exports.BuiltinMethod.ConcatArray: |
| name = 'concat'; |
| break; |
| case exports.BuiltinMethod.SubscribeObservable: |
| name = 'subscribe'; |
| break; |
| case exports.BuiltinMethod.Bind: |
| name = 'bind'; |
| break; |
| default: |
| throw new Error("Unknown builtin method: " + method); |
| } |
| return name; |
| }; |
| _TsEmitterVisitor.prototype._visitParams = function (params, ctx) { |
| var _this = this; |
| this.visitAllObjects(function (param) { |
| ctx.print(null, param.name); |
| _this._printColonType(param.type, ctx); |
| }, params, ctx, ','); |
| }; |
| _TsEmitterVisitor.prototype._visitIdentifier = function (value, typeParams, ctx) { |
| var _this = this; |
| var name = value.name, moduleName = value.moduleName; |
| if (this.referenceFilter && this.referenceFilter(value)) { |
| ctx.print(null, '(null as any)'); |
| return; |
| } |
| if (moduleName && (!this.importFilter || !this.importFilter(value))) { |
| var prefix = this.importsWithPrefixes.get(moduleName); |
| if (prefix == null) { |
| prefix = "i" + this.importsWithPrefixes.size; |
| this.importsWithPrefixes.set(moduleName, prefix); |
| } |
| ctx.print(null, prefix + "."); |
| } |
| ctx.print(null, name); |
| if (this.typeExpression > 0) { |
| // If we are in a type expression that refers to a generic type then supply |
| // the required type parameters. If there were not enough type parameters |
| // supplied, supply any as the type. Outside a type expression the reference |
| // should not supply type parameters and be treated as a simple value reference |
| // to the constructor function itself. |
| var suppliedParameters = typeParams || []; |
| if (suppliedParameters.length > 0) { |
| ctx.print(null, "<"); |
| this.visitAllObjects(function (type) { return type.visitType(_this, ctx); }, typeParams, ctx, ','); |
| ctx.print(null, ">"); |
| } |
| } |
| }; |
| _TsEmitterVisitor.prototype._printColonType = function (type, ctx, defaultType) { |
| if (type !== INFERRED_TYPE) { |
| ctx.print(null, ':'); |
| this.visitType(type, ctx, defaultType); |
| } |
| }; |
| return _TsEmitterVisitor; |
| }(AbstractEmitterVisitor)); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * Resolve a `Type` for {@link Pipe}. |
| * |
| * This interface can be overridden by the application developer to create custom behavior. |
| * |
| * See {@link Compiler} |
| */ |
| var PipeResolver = /** @class */ (function () { |
| function PipeResolver(_reflector) { |
| this._reflector = _reflector; |
| } |
| PipeResolver.prototype.isPipe = function (type) { |
| var typeMetadata = this._reflector.annotations(resolveForwardRef(type)); |
| return typeMetadata && typeMetadata.some(createPipe.isTypeOf); |
| }; |
| /** |
| * Return {@link Pipe} for a given `Type`. |
| */ |
| PipeResolver.prototype.resolve = function (type, throwIfNotFound) { |
| if (throwIfNotFound === void 0) { throwIfNotFound = true; } |
| var metas = this._reflector.annotations(resolveForwardRef(type)); |
| if (metas) { |
| var annotation = findLast(metas, createPipe.isTypeOf); |
| if (annotation) { |
| return annotation; |
| } |
| } |
| if (throwIfNotFound) { |
| throw new Error("No Pipe decorator found on " + stringify(type)); |
| } |
| return null; |
| }; |
| return PipeResolver; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * Generates code that is used to type check templates. |
| */ |
| var TypeCheckCompiler = /** @class */ (function () { |
| function TypeCheckCompiler(options, reflector) { |
| this.options = options; |
| this.reflector = reflector; |
| } |
| /** |
| * Important notes: |
| * - This must not produce new `import` statements, but only refer to types outside |
| * of the file via the variables provided via externalReferenceVars. |
| * This allows Typescript to reuse the old program's structure as no imports have changed. |
| * - This must not produce any exports, as this would pollute the .d.ts file |
| * and also violate the point above. |
| */ |
| TypeCheckCompiler.prototype.compileComponent = function (componentId, component, template, usedPipes, externalReferenceVars, ctx) { |
| var _this = this; |
| var pipes = new Map(); |
| usedPipes.forEach(function (p) { return pipes.set(p.name, p.type.reference); }); |
| var embeddedViewCount = 0; |
| var viewBuilderFactory = function (parent, guards) { |
| var embeddedViewIndex = embeddedViewCount++; |
| return new ViewBuilder(_this.options, _this.reflector, externalReferenceVars, parent, component.type.reference, component.isHost, embeddedViewIndex, pipes, guards, ctx, viewBuilderFactory); |
| }; |
| var visitor = viewBuilderFactory(null, []); |
| visitor.visitAll([], template); |
| return visitor.build(componentId); |
| }; |
| return TypeCheckCompiler; |
| }()); |
| var DYNAMIC_VAR_NAME = '_any'; |
| var TypeCheckLocalResolver = /** @class */ (function () { |
| function TypeCheckLocalResolver() { |
| } |
| TypeCheckLocalResolver.prototype.notifyImplicitReceiverUse = function () { }; |
| TypeCheckLocalResolver.prototype.getLocal = function (name) { |
| if (name === EventHandlerVars.event.name) { |
| // References to the event should not be type-checked. |
| // TODO(chuckj): determine a better type for the event. |
| return variable(DYNAMIC_VAR_NAME); |
| } |
| return null; |
| }; |
| return TypeCheckLocalResolver; |
| }()); |
| var defaultResolver = new TypeCheckLocalResolver(); |
| var ViewBuilder = /** @class */ (function () { |
| function ViewBuilder(options, reflector, externalReferenceVars, parent, component, isHostComponent, embeddedViewIndex, pipes, guards, ctx, viewBuilderFactory) { |
| this.options = options; |
| this.reflector = reflector; |
| this.externalReferenceVars = externalReferenceVars; |
| this.parent = parent; |
| this.component = component; |
| this.isHostComponent = isHostComponent; |
| this.embeddedViewIndex = embeddedViewIndex; |
| this.pipes = pipes; |
| this.guards = guards; |
| this.ctx = ctx; |
| this.viewBuilderFactory = viewBuilderFactory; |
| this.refOutputVars = new Map(); |
| this.variables = []; |
| this.children = []; |
| this.updates = []; |
| this.actions = []; |
| } |
| ViewBuilder.prototype.getOutputVar = function (type) { |
| var varName; |
| if (type === this.component && this.isHostComponent) { |
| varName = DYNAMIC_VAR_NAME; |
| } |
| else if (type instanceof StaticSymbol) { |
| varName = this.externalReferenceVars.get(type); |
| } |
| else { |
| varName = DYNAMIC_VAR_NAME; |
| } |
| if (!varName) { |
| throw new Error("Illegal State: referring to a type without a variable " + JSON.stringify(type)); |
| } |
| return varName; |
| }; |
| ViewBuilder.prototype.getTypeGuardExpressions = function (ast) { |
| var e_1, _a, e_2, _b; |
| var result = __spread(this.guards); |
| try { |
| for (var _c = __values(ast.directives), _d = _c.next(); !_d.done; _d = _c.next()) { |
| var directive = _d.value; |
| try { |
| for (var _e = __values(directive.inputs), _f = _e.next(); !_f.done; _f = _e.next()) { |
| var input = _f.value; |
| var guard = directive.directive.guards[input.directiveName]; |
| if (guard) { |
| var useIf = guard === 'UseIf'; |
| result.push({ |
| guard: guard, |
| useIf: useIf, |
| expression: { context: this.component, value: input.value } |
| }); |
| } |
| } |
| } |
| catch (e_2_1) { e_2 = { error: e_2_1 }; } |
| finally { |
| try { |
| if (_f && !_f.done && (_b = _e.return)) _b.call(_e); |
| } |
| finally { if (e_2) throw e_2.error; } |
| } |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (_d && !_d.done && (_a = _c.return)) _a.call(_c); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| return result; |
| }; |
| ViewBuilder.prototype.visitAll = function (variables, astNodes) { |
| this.variables = variables; |
| templateVisitAll(this, astNodes); |
| }; |
| ViewBuilder.prototype.build = function (componentId, targetStatements) { |
| var _this = this; |
| var e_3, _a; |
| if (targetStatements === void 0) { targetStatements = []; } |
| this.children.forEach(function (child) { return child.build(componentId, targetStatements); }); |
| var viewStmts = [variable(DYNAMIC_VAR_NAME).set(NULL_EXPR).toDeclStmt(DYNAMIC_TYPE)]; |
| var bindingCount = 0; |
| this.updates.forEach(function (expression) { |
| var _a = _this.preprocessUpdateExpression(expression), sourceSpan = _a.sourceSpan, context = _a.context, value = _a.value; |
| var bindingId = "" + bindingCount++; |
| var nameResolver = context === _this.component ? _this : defaultResolver; |
| var _b = convertPropertyBinding(nameResolver, variable(_this.getOutputVar(context)), value, bindingId, BindingForm.General), stmts = _b.stmts, currValExpr = _b.currValExpr; |
| stmts.push(new ExpressionStatement(currValExpr)); |
| viewStmts.push.apply(viewStmts, __spread(stmts.map(function (stmt) { return applySourceSpanToStatementIfNeeded(stmt, sourceSpan); }))); |
| }); |
| this.actions.forEach(function (_a) { |
| var sourceSpan = _a.sourceSpan, context = _a.context, value = _a.value; |
| var bindingId = "" + bindingCount++; |
| var nameResolver = context === _this.component ? _this : defaultResolver; |
| var stmts = convertActionBinding(nameResolver, variable(_this.getOutputVar(context)), value, bindingId).stmts; |
| viewStmts.push.apply(viewStmts, __spread(stmts.map(function (stmt) { return applySourceSpanToStatementIfNeeded(stmt, sourceSpan); }))); |
| }); |
| if (this.guards.length) { |
| var guardExpression = undefined; |
| try { |
| for (var _b = __values(this.guards), _c = _b.next(); !_c.done; _c = _b.next()) { |
| var guard = _c.value; |
| var _d = this.preprocessUpdateExpression(guard.expression), context = _d.context, value = _d.value; |
| var bindingId = "" + bindingCount++; |
| var nameResolver = context === this.component ? this : defaultResolver; |
| // We only support support simple expressions and ignore others as they |
| // are unlikely to affect type narrowing. |
| var _e = convertPropertyBinding(nameResolver, variable(this.getOutputVar(context)), value, bindingId, BindingForm.TrySimple), stmts = _e.stmts, currValExpr = _e.currValExpr; |
| if (stmts.length == 0) { |
| var guardClause = guard.useIf ? currValExpr : this.ctx.importExpr(guard.guard).callFn([currValExpr]); |
| guardExpression = guardExpression ? guardExpression.and(guardClause) : guardClause; |
| } |
| } |
| } |
| catch (e_3_1) { e_3 = { error: e_3_1 }; } |
| finally { |
| try { |
| if (_c && !_c.done && (_a = _b.return)) _a.call(_b); |
| } |
| finally { if (e_3) throw e_3.error; } |
| } |
| if (guardExpression) { |
| viewStmts = [new IfStmt(guardExpression, viewStmts)]; |
| } |
| } |
| var viewName = "_View_" + componentId + "_" + this.embeddedViewIndex; |
| var viewFactory = new DeclareFunctionStmt(viewName, [], viewStmts); |
| targetStatements.push(viewFactory); |
| return targetStatements; |
| }; |
| ViewBuilder.prototype.visitBoundText = function (ast, context) { |
| var _this = this; |
| var astWithSource = ast.value; |
| var inter = astWithSource.ast; |
| inter.expressions.forEach(function (expr) { |
| return _this.updates.push({ context: _this.component, value: expr, sourceSpan: ast.sourceSpan }); |
| }); |
| }; |
| ViewBuilder.prototype.visitEmbeddedTemplate = function (ast, context) { |
| this.visitElementOrTemplate(ast); |
| // Note: The old view compiler used to use an `any` type |
| // for the context in any embedded view. |
| // We keep this behaivor behind a flag for now. |
| if (this.options.fullTemplateTypeCheck) { |
| // Find any applicable type guards. For example, NgIf has a type guard on ngIf |
| // (see NgIf.ngIfTypeGuard) that can be used to indicate that a template is only |
| // stamped out if ngIf is truthy so any bindings in the template can assume that, |
| // if a nullable type is used for ngIf, that expression is not null or undefined. |
| var guards = this.getTypeGuardExpressions(ast); |
| var childVisitor = this.viewBuilderFactory(this, guards); |
| this.children.push(childVisitor); |
| childVisitor.visitAll(ast.variables, ast.children); |
| } |
| }; |
| ViewBuilder.prototype.visitElement = function (ast, context) { |
| var _this = this; |
| this.visitElementOrTemplate(ast); |
| ast.inputs.forEach(function (inputAst) { |
| _this.updates.push({ context: _this.component, value: inputAst.value, sourceSpan: inputAst.sourceSpan }); |
| }); |
| templateVisitAll(this, ast.children); |
| }; |
| ViewBuilder.prototype.visitElementOrTemplate = function (ast) { |
| var _this = this; |
| ast.directives.forEach(function (dirAst) { _this.visitDirective(dirAst); }); |
| ast.references.forEach(function (ref) { |
| var outputVarType = null; |
| // Note: The old view compiler used to use an `any` type |
| // for directives exposed via `exportAs`. |
| // We keep this behaivor behind a flag for now. |
| if (ref.value && ref.value.identifier && _this.options.fullTemplateTypeCheck) { |
| outputVarType = ref.value.identifier.reference; |
| } |
| else { |
| outputVarType = exports.BuiltinTypeName.Dynamic; |
| } |
| _this.refOutputVars.set(ref.name, outputVarType); |
| }); |
| ast.outputs.forEach(function (outputAst) { |
| _this.actions.push({ context: _this.component, value: outputAst.handler, sourceSpan: outputAst.sourceSpan }); |
| }); |
| }; |
| ViewBuilder.prototype.visitDirective = function (dirAst) { |
| var _this = this; |
| var dirType = dirAst.directive.type.reference; |
| dirAst.inputs.forEach(function (input) { return _this.updates.push({ context: _this.component, value: input.value, sourceSpan: input.sourceSpan }); }); |
| // Note: The old view compiler used to use an `any` type |
| // for expressions in host properties / events. |
| // We keep this behaivor behind a flag for now. |
| if (this.options.fullTemplateTypeCheck) { |
| dirAst.hostProperties.forEach(function (inputAst) { return _this.updates.push({ context: dirType, value: inputAst.value, sourceSpan: inputAst.sourceSpan }); }); |
| dirAst.hostEvents.forEach(function (hostEventAst) { return _this.actions.push({ |
| context: dirType, |
| value: hostEventAst.handler, |
| sourceSpan: hostEventAst.sourceSpan |
| }); }); |
| } |
| }; |
| ViewBuilder.prototype.notifyImplicitReceiverUse = function () { }; |
| ViewBuilder.prototype.getLocal = function (name) { |
| if (name == EventHandlerVars.event.name) { |
| return variable(this.getOutputVar(exports.BuiltinTypeName.Dynamic)); |
| } |
| for (var currBuilder = this; currBuilder; currBuilder = currBuilder.parent) { |
| var outputVarType = void 0; |
| // check references |
| outputVarType = currBuilder.refOutputVars.get(name); |
| if (outputVarType == null) { |
| // check variables |
| var varAst = currBuilder.variables.find(function (varAst) { return varAst.name === name; }); |
| if (varAst) { |
| outputVarType = exports.BuiltinTypeName.Dynamic; |
| } |
| } |
| if (outputVarType != null) { |
| return variable(this.getOutputVar(outputVarType)); |
| } |
| } |
| return null; |
| }; |
| ViewBuilder.prototype.pipeOutputVar = function (name) { |
| var pipe = this.pipes.get(name); |
| if (!pipe) { |
| throw new Error("Illegal State: Could not find pipe " + name + " in template of " + this.component); |
| } |
| return this.getOutputVar(pipe); |
| }; |
| ViewBuilder.prototype.preprocessUpdateExpression = function (expression) { |
| var _this = this; |
| return { |
| sourceSpan: expression.sourceSpan, |
| context: expression.context, |
| value: convertPropertyBindingBuiltins({ |
| createLiteralArrayConverter: function (argCount) { return function (args) { |
| var arr = literalArr(args); |
| // Note: The old view compiler used to use an `any` type |
| // for arrays. |
| return _this.options.fullTemplateTypeCheck ? arr : arr.cast(DYNAMIC_TYPE); |
| }; }, |
| createLiteralMapConverter: function (keys) { return function (values) { |
| var entries = keys.map(function (k, i) { return ({ |
| key: k.key, |
| value: values[i], |
| quoted: k.quoted, |
| }); }); |
| var map = literalMap(entries); |
| // Note: The old view compiler used to use an `any` type |
| // for maps. |
| return _this.options.fullTemplateTypeCheck ? map : map.cast(DYNAMIC_TYPE); |
| }; }, |
| createPipeConverter: function (name, argCount) { return function (args) { |
| // Note: The old view compiler used to use an `any` type |
| // for pipes. |
| var pipeExpr = _this.options.fullTemplateTypeCheck ? |
| variable(_this.pipeOutputVar(name)) : |
| variable(_this.getOutputVar(exports.BuiltinTypeName.Dynamic)); |
| return pipeExpr.callMethod('transform', args); |
| }; }, |
| }, expression.value) |
| }; |
| }; |
| ViewBuilder.prototype.visitNgContent = function (ast, context) { }; |
| ViewBuilder.prototype.visitText = function (ast, context) { }; |
| ViewBuilder.prototype.visitDirectiveProperty = function (ast, context) { }; |
| ViewBuilder.prototype.visitReference = function (ast, context) { }; |
| ViewBuilder.prototype.visitVariable = function (ast, context) { }; |
| ViewBuilder.prototype.visitEvent = function (ast, context) { }; |
| ViewBuilder.prototype.visitElementProperty = function (ast, context) { }; |
| ViewBuilder.prototype.visitAttr = function (ast, context) { }; |
| return ViewBuilder; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var CLASS_ATTR$1 = 'class'; |
| var STYLE_ATTR = 'style'; |
| var IMPLICIT_TEMPLATE_VAR = '\$implicit'; |
| var ViewCompileResult = /** @class */ (function () { |
| function ViewCompileResult(viewClassVar, rendererTypeVar) { |
| this.viewClassVar = viewClassVar; |
| this.rendererTypeVar = rendererTypeVar; |
| } |
| return ViewCompileResult; |
| }()); |
| var ViewCompiler = /** @class */ (function () { |
| function ViewCompiler(_reflector) { |
| this._reflector = _reflector; |
| } |
| ViewCompiler.prototype.compileComponent = function (outputCtx, component, template, styles, usedPipes) { |
| var _this = this; |
| var _a; |
| var embeddedViewCount = 0; |
| var staticQueryIds = findStaticQueryIds(template); |
| var renderComponentVarName = undefined; |
| if (!component.isHost) { |
| var template_1 = component.template; |
| var customRenderData = []; |
| if (template_1.animations && template_1.animations.length) { |
| customRenderData.push(new LiteralMapEntry('animation', convertValueToOutputAst(outputCtx, template_1.animations), true)); |
| } |
| var renderComponentVar = variable(rendererTypeName(component.type.reference)); |
| renderComponentVarName = renderComponentVar.name; |
| outputCtx.statements.push(renderComponentVar |
| .set(importExpr(Identifiers.createRendererType2).callFn([new LiteralMapExpr([ |
| new LiteralMapEntry('encapsulation', literal(template_1.encapsulation), false), |
| new LiteralMapEntry('styles', styles, false), |
| new LiteralMapEntry('data', new LiteralMapExpr(customRenderData), false) |
| ])])) |
| .toDeclStmt(importType(Identifiers.RendererType2), [exports.StmtModifier.Final, exports.StmtModifier.Exported])); |
| } |
| var viewBuilderFactory = function (parent) { |
| var embeddedViewIndex = embeddedViewCount++; |
| return new ViewBuilder$1(_this._reflector, outputCtx, parent, component, embeddedViewIndex, usedPipes, staticQueryIds, viewBuilderFactory); |
| }; |
| var visitor = viewBuilderFactory(null); |
| visitor.visitAll([], template); |
| (_a = outputCtx.statements).push.apply(_a, __spread(visitor.build())); |
| return new ViewCompileResult(visitor.viewName, renderComponentVarName); |
| }; |
| return ViewCompiler; |
| }()); |
| var LOG_VAR$1 = variable('_l'); |
| var VIEW_VAR = variable('_v'); |
| var CHECK_VAR = variable('_ck'); |
| var COMP_VAR = variable('_co'); |
| var EVENT_NAME_VAR = variable('en'); |
| var ALLOW_DEFAULT_VAR = variable("ad"); |
| var ViewBuilder$1 = /** @class */ (function () { |
| function ViewBuilder(reflector, outputCtx, parent, component, embeddedViewIndex, usedPipes, staticQueryIds, viewBuilderFactory) { |
| this.reflector = reflector; |
| this.outputCtx = outputCtx; |
| this.parent = parent; |
| this.component = component; |
| this.embeddedViewIndex = embeddedViewIndex; |
| this.usedPipes = usedPipes; |
| this.staticQueryIds = staticQueryIds; |
| this.viewBuilderFactory = viewBuilderFactory; |
| this.nodes = []; |
| this.purePipeNodeIndices = Object.create(null); |
| // Need Object.create so that we don't have builtin values... |
| this.refNodeIndices = Object.create(null); |
| this.variables = []; |
| this.children = []; |
| // TODO(tbosch): The old view compiler used to use an `any` type |
| // for the context in any embedded view. We keep this behaivor for now |
| // to be able to introduce the new view compiler without too many errors. |
| this.compType = this.embeddedViewIndex > 0 ? |
| DYNAMIC_TYPE : |
| expressionType(outputCtx.importExpr(this.component.type.reference)); |
| this.viewName = viewClassName(this.component.type.reference, this.embeddedViewIndex); |
| } |
| ViewBuilder.prototype.visitAll = function (variables, astNodes) { |
| var _this = this; |
| this.variables = variables; |
| // create the pipes for the pure pipes immediately, so that we know their indices. |
| if (!this.parent) { |
| this.usedPipes.forEach(function (pipe) { |
| if (pipe.pure) { |
| _this.purePipeNodeIndices[pipe.name] = _this._createPipe(null, pipe); |
| } |
| }); |
| } |
| if (!this.parent) { |
| var queryIds_1 = staticViewQueryIds(this.staticQueryIds); |
| this.component.viewQueries.forEach(function (query, queryIndex) { |
| // Note: queries start with id 1 so we can use the number in a Bloom filter! |
| var queryId = queryIndex + 1; |
| var bindingType = query.first ? 0 /* First */ : 1 /* All */; |
| var flags = 134217728 /* TypeViewQuery */ | calcStaticDynamicQueryFlags(queryIds_1, queryId, query); |
| _this.nodes.push(function () { return ({ |
| sourceSpan: null, |
| nodeFlags: flags, |
| nodeDef: importExpr(Identifiers.queryDef).callFn([ |
| literal(flags), literal(queryId), |
| new LiteralMapExpr([new LiteralMapEntry(query.propertyName, literal(bindingType), false)]) |
| ]) |
| }); }); |
| }); |
| } |
| templateVisitAll(this, astNodes); |
| if (this.parent && (astNodes.length === 0 || needsAdditionalRootNode(astNodes))) { |
| // if the view is an embedded view, then we need to add an additional root node in some cases |
| this.nodes.push(function () { return ({ |
| sourceSpan: null, |
| nodeFlags: 1 /* TypeElement */, |
| nodeDef: importExpr(Identifiers.anchorDef).callFn([ |
| literal(0 /* None */), NULL_EXPR, NULL_EXPR, literal(0) |
| ]) |
| }); }); |
| } |
| }; |
| ViewBuilder.prototype.build = function (targetStatements) { |
| if (targetStatements === void 0) { targetStatements = []; } |
| this.children.forEach(function (child) { return child.build(targetStatements); }); |
| var _a = this._createNodeExpressions(), updateRendererStmts = _a.updateRendererStmts, updateDirectivesStmts = _a.updateDirectivesStmts, nodeDefExprs = _a.nodeDefExprs; |
| var updateRendererFn = this._createUpdateFn(updateRendererStmts); |
| var updateDirectivesFn = this._createUpdateFn(updateDirectivesStmts); |
| var viewFlags = 0 /* None */; |
| if (!this.parent && this.component.changeDetection === ChangeDetectionStrategy.OnPush) { |
| viewFlags |= 2 /* OnPush */; |
| } |
| var viewFactory = new DeclareFunctionStmt(this.viewName, [new FnParam(LOG_VAR$1.name)], [new ReturnStatement(importExpr(Identifiers.viewDef).callFn([ |
| literal(viewFlags), |
| literalArr(nodeDefExprs), |
| updateDirectivesFn, |
| updateRendererFn, |
| ]))], importType(Identifiers.ViewDefinition), this.embeddedViewIndex === 0 ? [exports.StmtModifier.Exported] : []); |
| targetStatements.push(viewFactory); |
| return targetStatements; |
| }; |
| ViewBuilder.prototype._createUpdateFn = function (updateStmts) { |
| var updateFn; |
| if (updateStmts.length > 0) { |
| var preStmts = []; |
| if (!this.component.isHost && findReadVarNames(updateStmts).has(COMP_VAR.name)) { |
| preStmts.push(COMP_VAR.set(VIEW_VAR.prop('component')).toDeclStmt(this.compType)); |
| } |
| updateFn = fn([ |
| new FnParam(CHECK_VAR.name, INFERRED_TYPE), |
| new FnParam(VIEW_VAR.name, INFERRED_TYPE) |
| ], __spread(preStmts, updateStmts), INFERRED_TYPE); |
| } |
| else { |
| updateFn = NULL_EXPR; |
| } |
| return updateFn; |
| }; |
| ViewBuilder.prototype.visitNgContent = function (ast, context) { |
| // ngContentDef(ngContentIndex: number, index: number): NodeDef; |
| this.nodes.push(function () { return ({ |
| sourceSpan: ast.sourceSpan, |
| nodeFlags: 8 /* TypeNgContent */, |
| nodeDef: importExpr(Identifiers.ngContentDef).callFn([ |
| literal(ast.ngContentIndex), literal(ast.index) |
| ]) |
| }); }); |
| }; |
| ViewBuilder.prototype.visitText = function (ast, context) { |
| // Static text nodes have no check function |
| var checkIndex = -1; |
| this.nodes.push(function () { return ({ |
| sourceSpan: ast.sourceSpan, |
| nodeFlags: 2 /* TypeText */, |
| nodeDef: importExpr(Identifiers.textDef).callFn([ |
| literal(checkIndex), |
| literal(ast.ngContentIndex), |
| literalArr([literal(ast.value)]), |
| ]) |
| }); }); |
| }; |
| ViewBuilder.prototype.visitBoundText = function (ast, context) { |
| var _this = this; |
| var nodeIndex = this.nodes.length; |
| // reserve the space in the nodeDefs array |
| this.nodes.push(null); |
| var astWithSource = ast.value; |
| var inter = astWithSource.ast; |
| var updateRendererExpressions = inter.expressions.map(function (expr, bindingIndex) { return _this._preprocessUpdateExpression({ nodeIndex: nodeIndex, bindingIndex: bindingIndex, sourceSpan: ast.sourceSpan, context: COMP_VAR, value: expr }); }); |
| // Check index is the same as the node index during compilation |
| // They might only differ at runtime |
| var checkIndex = nodeIndex; |
| this.nodes[nodeIndex] = function () { return ({ |
| sourceSpan: ast.sourceSpan, |
| nodeFlags: 2 /* TypeText */, |
| nodeDef: importExpr(Identifiers.textDef).callFn([ |
| literal(checkIndex), |
| literal(ast.ngContentIndex), |
| literalArr(inter.strings.map(function (s) { return literal(s); })), |
| ]), |
| updateRenderer: updateRendererExpressions |
| }); }; |
| }; |
| ViewBuilder.prototype.visitEmbeddedTemplate = function (ast, context) { |
| var _this = this; |
| var nodeIndex = this.nodes.length; |
| // reserve the space in the nodeDefs array |
| this.nodes.push(null); |
| var _a = this._visitElementOrTemplate(nodeIndex, ast), flags = _a.flags, queryMatchesExpr = _a.queryMatchesExpr, hostEvents = _a.hostEvents; |
| var childVisitor = this.viewBuilderFactory(this); |
| this.children.push(childVisitor); |
| childVisitor.visitAll(ast.variables, ast.children); |
| var childCount = this.nodes.length - nodeIndex - 1; |
| // anchorDef( |
| // flags: NodeFlags, matchedQueries: [string, QueryValueType][], ngContentIndex: number, |
| // childCount: number, handleEventFn?: ElementHandleEventFn, templateFactory?: |
| // ViewDefinitionFactory): NodeDef; |
| this.nodes[nodeIndex] = function () { return ({ |
| sourceSpan: ast.sourceSpan, |
| nodeFlags: 1 /* TypeElement */ | flags, |
| nodeDef: importExpr(Identifiers.anchorDef).callFn([ |
| literal(flags), |
| queryMatchesExpr, |
| literal(ast.ngContentIndex), |
| literal(childCount), |
| _this._createElementHandleEventFn(nodeIndex, hostEvents), |
| variable(childVisitor.viewName), |
| ]) |
| }); }; |
| }; |
| ViewBuilder.prototype.visitElement = function (ast, context) { |
| var _this = this; |
| var nodeIndex = this.nodes.length; |
| // reserve the space in the nodeDefs array so we can add children |
| this.nodes.push(null); |
| // Using a null element name creates an anchor. |
| var elName = isNgContainer(ast.name) ? null : ast.name; |
| var _a = this._visitElementOrTemplate(nodeIndex, ast), flags = _a.flags, usedEvents = _a.usedEvents, queryMatchesExpr = _a.queryMatchesExpr, dirHostBindings = _a.hostBindings, hostEvents = _a.hostEvents; |
| var inputDefs = []; |
| var updateRendererExpressions = []; |
| var outputDefs = []; |
| if (elName) { |
| var hostBindings = ast.inputs |
| .map(function (inputAst) { return ({ |
| context: COMP_VAR, |
| inputAst: inputAst, |
| dirAst: null, |
| }); }) |
| .concat(dirHostBindings); |
| if (hostBindings.length) { |
| updateRendererExpressions = |
| hostBindings.map(function (hostBinding, bindingIndex) { return _this._preprocessUpdateExpression({ |
| context: hostBinding.context, |
| nodeIndex: nodeIndex, |
| bindingIndex: bindingIndex, |
| sourceSpan: hostBinding.inputAst.sourceSpan, |
| value: hostBinding.inputAst.value |
| }); }); |
| inputDefs = hostBindings.map(function (hostBinding) { return elementBindingDef(hostBinding.inputAst, hostBinding.dirAst); }); |
| } |
| outputDefs = usedEvents.map(function (_a) { |
| var _b = __read(_a, 2), target = _b[0], eventName = _b[1]; |
| return literalArr([literal(target), literal(eventName)]); |
| }); |
| } |
| templateVisitAll(this, ast.children); |
| var childCount = this.nodes.length - nodeIndex - 1; |
| var compAst = ast.directives.find(function (dirAst) { return dirAst.directive.isComponent; }); |
| var compRendererType = NULL_EXPR; |
| var compView = NULL_EXPR; |
| if (compAst) { |
| compView = this.outputCtx.importExpr(compAst.directive.componentViewType); |
| compRendererType = this.outputCtx.importExpr(compAst.directive.rendererType); |
| } |
| // Check index is the same as the node index during compilation |
| // They might only differ at runtime |
| var checkIndex = nodeIndex; |
| this.nodes[nodeIndex] = function () { return ({ |
| sourceSpan: ast.sourceSpan, |
| nodeFlags: 1 /* TypeElement */ | flags, |
| nodeDef: importExpr(Identifiers.elementDef).callFn([ |
| literal(checkIndex), |
| literal(flags), |
| queryMatchesExpr, |
| literal(ast.ngContentIndex), |
| literal(childCount), |
| literal(elName), |
| elName ? fixedAttrsDef(ast) : NULL_EXPR, |
| inputDefs.length ? literalArr(inputDefs) : NULL_EXPR, |
| outputDefs.length ? literalArr(outputDefs) : NULL_EXPR, |
| _this._createElementHandleEventFn(nodeIndex, hostEvents), |
| compView, |
| compRendererType, |
| ]), |
| updateRenderer: updateRendererExpressions |
| }); }; |
| }; |
| ViewBuilder.prototype._visitElementOrTemplate = function (nodeIndex, ast) { |
| var _this = this; |
| var flags = 0 /* None */; |
| if (ast.hasViewContainer) { |
| flags |= 16777216 /* EmbeddedViews */; |
| } |
| var usedEvents = new Map(); |
| ast.outputs.forEach(function (event) { |
| var _a = elementEventNameAndTarget(event, null), name = _a.name, target = _a.target; |
| usedEvents.set(elementEventFullName(target, name), [target, name]); |
| }); |
| ast.directives.forEach(function (dirAst) { |
| dirAst.hostEvents.forEach(function (event) { |
| var _a = elementEventNameAndTarget(event, dirAst), name = _a.name, target = _a.target; |
| usedEvents.set(elementEventFullName(target, name), [target, name]); |
| }); |
| }); |
| var hostBindings = []; |
| var hostEvents = []; |
| this._visitComponentFactoryResolverProvider(ast.directives); |
| ast.providers.forEach(function (providerAst, providerIndex) { |
| var dirAst = undefined; |
| var dirIndex = undefined; |
| ast.directives.forEach(function (localDirAst, i) { |
| if (localDirAst.directive.type.reference === tokenReference(providerAst.token)) { |
| dirAst = localDirAst; |
| dirIndex = i; |
| } |
| }); |
| if (dirAst) { |
| var _a = _this._visitDirective(providerAst, dirAst, dirIndex, nodeIndex, ast.references, ast.queryMatches, usedEvents, _this.staticQueryIds.get(ast)), dirHostBindings = _a.hostBindings, dirHostEvents = _a.hostEvents; |
| hostBindings.push.apply(hostBindings, __spread(dirHostBindings)); |
| hostEvents.push.apply(hostEvents, __spread(dirHostEvents)); |
| } |
| else { |
| _this._visitProvider(providerAst, ast.queryMatches); |
| } |
| }); |
| var queryMatchExprs = []; |
| ast.queryMatches.forEach(function (match) { |
| var valueType = undefined; |
| if (tokenReference(match.value) === |
| _this.reflector.resolveExternalReference(Identifiers.ElementRef)) { |
| valueType = 0 /* ElementRef */; |
| } |
| else if (tokenReference(match.value) === |
| _this.reflector.resolveExternalReference(Identifiers.ViewContainerRef)) { |
| valueType = 3 /* ViewContainerRef */; |
| } |
| else if (tokenReference(match.value) === |
| _this.reflector.resolveExternalReference(Identifiers.TemplateRef)) { |
| valueType = 2 /* TemplateRef */; |
| } |
| if (valueType != null) { |
| queryMatchExprs.push(literalArr([literal(match.queryId), literal(valueType)])); |
| } |
| }); |
| ast.references.forEach(function (ref) { |
| var valueType = undefined; |
| if (!ref.value) { |
| valueType = 1 /* RenderElement */; |
| } |
| else if (tokenReference(ref.value) === |
| _this.reflector.resolveExternalReference(Identifiers.TemplateRef)) { |
| valueType = 2 /* TemplateRef */; |
| } |
| if (valueType != null) { |
| _this.refNodeIndices[ref.name] = nodeIndex; |
| queryMatchExprs.push(literalArr([literal(ref.name), literal(valueType)])); |
| } |
| }); |
| ast.outputs.forEach(function (outputAst) { |
| hostEvents.push({ context: COMP_VAR, eventAst: outputAst, dirAst: null }); |
| }); |
| return { |
| flags: flags, |
| usedEvents: Array.from(usedEvents.values()), |
| queryMatchesExpr: queryMatchExprs.length ? literalArr(queryMatchExprs) : NULL_EXPR, |
| hostBindings: hostBindings, |
| hostEvents: hostEvents |
| }; |
| }; |
| ViewBuilder.prototype._visitDirective = function (providerAst, dirAst, directiveIndex, elementNodeIndex, refs, queryMatches, usedEvents, queryIds) { |
| var _this = this; |
| var nodeIndex = this.nodes.length; |
| // reserve the space in the nodeDefs array so we can add children |
| this.nodes.push(null); |
| dirAst.directive.queries.forEach(function (query, queryIndex) { |
| var queryId = dirAst.contentQueryStartId + queryIndex; |
| var flags = 67108864 /* TypeContentQuery */ | calcStaticDynamicQueryFlags(queryIds, queryId, query); |
| var bindingType = query.first ? 0 /* First */ : 1 /* All */; |
| _this.nodes.push(function () { return ({ |
| sourceSpan: dirAst.sourceSpan, |
| nodeFlags: flags, |
| nodeDef: importExpr(Identifiers.queryDef).callFn([ |
| literal(flags), literal(queryId), |
| new LiteralMapExpr([new LiteralMapEntry(query.propertyName, literal(bindingType), false)]) |
| ]), |
| }); }); |
| }); |
| // Note: the operation below might also create new nodeDefs, |
| // but we don't want them to be a child of a directive, |
| // as they might be a provider/pipe on their own. |
| // I.e. we only allow queries as children of directives nodes. |
| var childCount = this.nodes.length - nodeIndex - 1; |
| var _a = this._visitProviderOrDirective(providerAst, queryMatches), flags = _a.flags, queryMatchExprs = _a.queryMatchExprs, providerExpr = _a.providerExpr, depsExpr = _a.depsExpr; |
| refs.forEach(function (ref) { |
| if (ref.value && tokenReference(ref.value) === tokenReference(providerAst.token)) { |
| _this.refNodeIndices[ref.name] = nodeIndex; |
| queryMatchExprs.push(literalArr([literal(ref.name), literal(4 /* Provider */)])); |
| } |
| }); |
| if (dirAst.directive.isComponent) { |
| flags |= 32768 /* Component */; |
| } |
| var inputDefs = dirAst.inputs.map(function (inputAst, inputIndex) { |
| var mapValue = literalArr([literal(inputIndex), literal(inputAst.directiveName)]); |
| // Note: it's important to not quote the key so that we can capture renames by minifiers! |
| return new LiteralMapEntry(inputAst.directiveName, mapValue, false); |
| }); |
| var outputDefs = []; |
| var dirMeta = dirAst.directive; |
| Object.keys(dirMeta.outputs).forEach(function (propName) { |
| var eventName = dirMeta.outputs[propName]; |
| if (usedEvents.has(eventName)) { |
| // Note: it's important to not quote the key so that we can capture renames by minifiers! |
| outputDefs.push(new LiteralMapEntry(propName, literal(eventName), false)); |
| } |
| }); |
| var updateDirectiveExpressions = []; |
| if (dirAst.inputs.length || (flags & (262144 /* DoCheck */ | 65536 /* OnInit */)) > 0) { |
| updateDirectiveExpressions = |
| dirAst.inputs.map(function (input, bindingIndex) { return _this._preprocessUpdateExpression({ |
| nodeIndex: nodeIndex, |
| bindingIndex: bindingIndex, |
| sourceSpan: input.sourceSpan, |
| context: COMP_VAR, |
| value: input.value |
| }); }); |
| } |
| var dirContextExpr = importExpr(Identifiers.nodeValue).callFn([VIEW_VAR, literal(nodeIndex)]); |
| var hostBindings = dirAst.hostProperties.map(function (inputAst) { return ({ |
| context: dirContextExpr, |
| dirAst: dirAst, |
| inputAst: inputAst, |
| }); }); |
| var hostEvents = dirAst.hostEvents.map(function (hostEventAst) { return ({ |
| context: dirContextExpr, |
| eventAst: hostEventAst, dirAst: dirAst, |
| }); }); |
| // Check index is the same as the node index during compilation |
| // They might only differ at runtime |
| var checkIndex = nodeIndex; |
| this.nodes[nodeIndex] = function () { return ({ |
| sourceSpan: dirAst.sourceSpan, |
| nodeFlags: 16384 /* TypeDirective */ | flags, |
| nodeDef: importExpr(Identifiers.directiveDef).callFn([ |
| literal(checkIndex), |
| literal(flags), |
| queryMatchExprs.length ? literalArr(queryMatchExprs) : NULL_EXPR, |
| literal(childCount), |
| providerExpr, |
| depsExpr, |
| inputDefs.length ? new LiteralMapExpr(inputDefs) : NULL_EXPR, |
| outputDefs.length ? new LiteralMapExpr(outputDefs) : NULL_EXPR, |
| ]), |
| updateDirectives: updateDirectiveExpressions, |
| directive: dirAst.directive.type, |
| }); }; |
| return { hostBindings: hostBindings, hostEvents: hostEvents }; |
| }; |
| ViewBuilder.prototype._visitProvider = function (providerAst, queryMatches) { |
| this._addProviderNode(this._visitProviderOrDirective(providerAst, queryMatches)); |
| }; |
| ViewBuilder.prototype._visitComponentFactoryResolverProvider = function (directives) { |
| var componentDirMeta = directives.find(function (dirAst) { return dirAst.directive.isComponent; }); |
| if (componentDirMeta && componentDirMeta.directive.entryComponents.length) { |
| var _a = componentFactoryResolverProviderDef(this.reflector, this.outputCtx, 8192 /* PrivateProvider */, componentDirMeta.directive.entryComponents), providerExpr = _a.providerExpr, depsExpr = _a.depsExpr, flags = _a.flags, tokenExpr = _a.tokenExpr; |
| this._addProviderNode({ |
| providerExpr: providerExpr, |
| depsExpr: depsExpr, |
| flags: flags, |
| tokenExpr: tokenExpr, |
| queryMatchExprs: [], |
| sourceSpan: componentDirMeta.sourceSpan |
| }); |
| } |
| }; |
| ViewBuilder.prototype._addProviderNode = function (data) { |
| var nodeIndex = this.nodes.length; |
| // providerDef( |
| // flags: NodeFlags, matchedQueries: [string, QueryValueType][], token:any, |
| // value: any, deps: ([DepFlags, any] | any)[]): NodeDef; |
| this.nodes.push(function () { return ({ |
| sourceSpan: data.sourceSpan, |
| nodeFlags: data.flags, |
| nodeDef: importExpr(Identifiers.providerDef).callFn([ |
| literal(data.flags), |
| data.queryMatchExprs.length ? literalArr(data.queryMatchExprs) : NULL_EXPR, |
| data.tokenExpr, data.providerExpr, data.depsExpr |
| ]) |
| }); }); |
| }; |
| ViewBuilder.prototype._visitProviderOrDirective = function (providerAst, queryMatches) { |
| var flags = 0 /* None */; |
| var queryMatchExprs = []; |
| queryMatches.forEach(function (match) { |
| if (tokenReference(match.value) === tokenReference(providerAst.token)) { |
| queryMatchExprs.push(literalArr([literal(match.queryId), literal(4 /* Provider */)])); |
| } |
| }); |
| var _a = providerDef(this.outputCtx, providerAst), providerExpr = _a.providerExpr, depsExpr = _a.depsExpr, providerFlags = _a.flags, tokenExpr = _a.tokenExpr; |
| return { |
| flags: flags | providerFlags, |
| queryMatchExprs: queryMatchExprs, |
| providerExpr: providerExpr, |
| depsExpr: depsExpr, |
| tokenExpr: tokenExpr, |
| sourceSpan: providerAst.sourceSpan |
| }; |
| }; |
| ViewBuilder.prototype.getLocal = function (name) { |
| if (name == EventHandlerVars.event.name) { |
| return EventHandlerVars.event; |
| } |
| var currViewExpr = VIEW_VAR; |
| for (var currBuilder = this; currBuilder; currBuilder = currBuilder.parent, |
| currViewExpr = currViewExpr.prop('parent').cast(DYNAMIC_TYPE)) { |
| // check references |
| var refNodeIndex = currBuilder.refNodeIndices[name]; |
| if (refNodeIndex != null) { |
| return importExpr(Identifiers.nodeValue).callFn([currViewExpr, literal(refNodeIndex)]); |
| } |
| // check variables |
| var varAst = currBuilder.variables.find(function (varAst) { return varAst.name === name; }); |
| if (varAst) { |
| var varValue = varAst.value || IMPLICIT_TEMPLATE_VAR; |
| return currViewExpr.prop('context').prop(varValue); |
| } |
| } |
| return null; |
| }; |
| ViewBuilder.prototype.notifyImplicitReceiverUse = function () { |
| // Not needed in View Engine as View Engine walks through the generated |
| // expressions to figure out if the implicit receiver is used and needs |
| // to be generated as part of the pre-update statements. |
| }; |
| ViewBuilder.prototype._createLiteralArrayConverter = function (sourceSpan, argCount) { |
| if (argCount === 0) { |
| var valueExpr_1 = importExpr(Identifiers.EMPTY_ARRAY); |
| return function () { return valueExpr_1; }; |
| } |
| var checkIndex = this.nodes.length; |
| this.nodes.push(function () { return ({ |
| sourceSpan: sourceSpan, |
| nodeFlags: 32 /* TypePureArray */, |
| nodeDef: importExpr(Identifiers.pureArrayDef).callFn([ |
| literal(checkIndex), |
| literal(argCount), |
| ]) |
| }); }); |
| return function (args) { return callCheckStmt(checkIndex, args); }; |
| }; |
| ViewBuilder.prototype._createLiteralMapConverter = function (sourceSpan, keys) { |
| if (keys.length === 0) { |
| var valueExpr_2 = importExpr(Identifiers.EMPTY_MAP); |
| return function () { return valueExpr_2; }; |
| } |
| var map = literalMap(keys.map(function (e, i) { return (__assign({}, e, { value: literal(i) })); })); |
| var checkIndex = this.nodes.length; |
| this.nodes.push(function () { return ({ |
| sourceSpan: sourceSpan, |
| nodeFlags: 64 /* TypePureObject */, |
| nodeDef: importExpr(Identifiers.pureObjectDef).callFn([ |
| literal(checkIndex), |
| map, |
| ]) |
| }); }); |
| return function (args) { return callCheckStmt(checkIndex, args); }; |
| }; |
| ViewBuilder.prototype._createPipeConverter = function (expression, name, argCount) { |
| var pipe = this.usedPipes.find(function (pipeSummary) { return pipeSummary.name === name; }); |
| if (pipe.pure) { |
| var checkIndex_1 = this.nodes.length; |
| this.nodes.push(function () { return ({ |
| sourceSpan: expression.sourceSpan, |
| nodeFlags: 128 /* TypePurePipe */, |
| nodeDef: importExpr(Identifiers.purePipeDef).callFn([ |
| literal(checkIndex_1), |
| literal(argCount), |
| ]) |
| }); }); |
| // find underlying pipe in the component view |
| var compViewExpr = VIEW_VAR; |
| var compBuilder = this; |
| while (compBuilder.parent) { |
| compBuilder = compBuilder.parent; |
| compViewExpr = compViewExpr.prop('parent').cast(DYNAMIC_TYPE); |
| } |
| var pipeNodeIndex = compBuilder.purePipeNodeIndices[name]; |
| var pipeValueExpr_1 = importExpr(Identifiers.nodeValue).callFn([compViewExpr, literal(pipeNodeIndex)]); |
| return function (args) { return callUnwrapValue(expression.nodeIndex, expression.bindingIndex, callCheckStmt(checkIndex_1, [pipeValueExpr_1].concat(args))); }; |
| } |
| else { |
| var nodeIndex = this._createPipe(expression.sourceSpan, pipe); |
| var nodeValueExpr_1 = importExpr(Identifiers.nodeValue).callFn([VIEW_VAR, literal(nodeIndex)]); |
| return function (args) { return callUnwrapValue(expression.nodeIndex, expression.bindingIndex, nodeValueExpr_1.callMethod('transform', args)); }; |
| } |
| }; |
| ViewBuilder.prototype._createPipe = function (sourceSpan, pipe) { |
| var _this = this; |
| var nodeIndex = this.nodes.length; |
| var flags = 0 /* None */; |
| pipe.type.lifecycleHooks.forEach(function (lifecycleHook) { |
| // for pipes, we only support ngOnDestroy |
| if (lifecycleHook === LifecycleHooks.OnDestroy) { |
| flags |= lifecycleHookToNodeFlag(lifecycleHook); |
| } |
| }); |
| var depExprs = pipe.type.diDeps.map(function (diDep) { return depDef(_this.outputCtx, diDep); }); |
| // function pipeDef( |
| // flags: NodeFlags, ctor: any, deps: ([DepFlags, any] | any)[]): NodeDef |
| this.nodes.push(function () { return ({ |
| sourceSpan: sourceSpan, |
| nodeFlags: 16 /* TypePipe */, |
| nodeDef: importExpr(Identifiers.pipeDef).callFn([ |
| literal(flags), _this.outputCtx.importExpr(pipe.type.reference), literalArr(depExprs) |
| ]) |
| }); }); |
| return nodeIndex; |
| }; |
| /** |
| * For the AST in `UpdateExpression.value`: |
| * - create nodes for pipes, literal arrays and, literal maps, |
| * - update the AST to replace pipes, literal arrays and, literal maps with calls to check fn. |
| * |
| * WARNING: This might create new nodeDefs (for pipes and literal arrays and literal maps)! |
| */ |
| ViewBuilder.prototype._preprocessUpdateExpression = function (expression) { |
| var _this = this; |
| return { |
| nodeIndex: expression.nodeIndex, |
| bindingIndex: expression.bindingIndex, |
| sourceSpan: expression.sourceSpan, |
| context: expression.context, |
| value: convertPropertyBindingBuiltins({ |
| createLiteralArrayConverter: function (argCount) { return _this._createLiteralArrayConverter(expression.sourceSpan, argCount); }, |
| createLiteralMapConverter: function (keys) { |
| return _this._createLiteralMapConverter(expression.sourceSpan, keys); |
| }, |
| createPipeConverter: function (name, argCount) { |
| return _this._createPipeConverter(expression, name, argCount); |
| } |
| }, expression.value) |
| }; |
| }; |
| ViewBuilder.prototype._createNodeExpressions = function () { |
| var self = this; |
| var updateBindingCount = 0; |
| var updateRendererStmts = []; |
| var updateDirectivesStmts = []; |
| var nodeDefExprs = this.nodes.map(function (factory, nodeIndex) { |
| var _a = factory(), nodeDef = _a.nodeDef, nodeFlags = _a.nodeFlags, updateDirectives = _a.updateDirectives, updateRenderer = _a.updateRenderer, sourceSpan = _a.sourceSpan; |
| if (updateRenderer) { |
| updateRendererStmts.push.apply(updateRendererStmts, __spread(createUpdateStatements(nodeIndex, sourceSpan, updateRenderer, false))); |
| } |
| if (updateDirectives) { |
| updateDirectivesStmts.push.apply(updateDirectivesStmts, __spread(createUpdateStatements(nodeIndex, sourceSpan, updateDirectives, (nodeFlags & (262144 /* DoCheck */ | 65536 /* OnInit */)) > 0))); |
| } |
| // We use a comma expression to call the log function before |
| // the nodeDef function, but still use the result of the nodeDef function |
| // as the value. |
| // Note: We only add the logger to elements / text nodes, |
| // so we don't generate too much code. |
| var logWithNodeDef = nodeFlags & 3 /* CatRenderNode */ ? |
| new CommaExpr([LOG_VAR$1.callFn([]).callFn([]), nodeDef]) : |
| nodeDef; |
| return applySourceSpanToExpressionIfNeeded(logWithNodeDef, sourceSpan); |
| }); |
| return { updateRendererStmts: updateRendererStmts, updateDirectivesStmts: updateDirectivesStmts, nodeDefExprs: nodeDefExprs }; |
| function createUpdateStatements(nodeIndex, sourceSpan, expressions, allowEmptyExprs) { |
| var updateStmts = []; |
| var exprs = expressions.map(function (_a) { |
| var sourceSpan = _a.sourceSpan, context = _a.context, value = _a.value; |
| var bindingId = "" + updateBindingCount++; |
| var nameResolver = context === COMP_VAR ? self : null; |
| var _b = convertPropertyBinding(nameResolver, context, value, bindingId, BindingForm.General), stmts = _b.stmts, currValExpr = _b.currValExpr; |
| updateStmts.push.apply(updateStmts, __spread(stmts.map(function (stmt) { return applySourceSpanToStatementIfNeeded(stmt, sourceSpan); }))); |
| return applySourceSpanToExpressionIfNeeded(currValExpr, sourceSpan); |
| }); |
| if (expressions.length || allowEmptyExprs) { |
| updateStmts.push(applySourceSpanToStatementIfNeeded(callCheckStmt(nodeIndex, exprs).toStmt(), sourceSpan)); |
| } |
| return updateStmts; |
| } |
| }; |
| ViewBuilder.prototype._createElementHandleEventFn = function (nodeIndex, handlers) { |
| var _this = this; |
| var handleEventStmts = []; |
| var handleEventBindingCount = 0; |
| handlers.forEach(function (_a) { |
| var context = _a.context, eventAst = _a.eventAst, dirAst = _a.dirAst; |
| var bindingId = "" + handleEventBindingCount++; |
| var nameResolver = context === COMP_VAR ? _this : null; |
| var _b = convertActionBinding(nameResolver, context, eventAst.handler, bindingId), stmts = _b.stmts, allowDefault = _b.allowDefault; |
| var trueStmts = stmts; |
| if (allowDefault) { |
| trueStmts.push(ALLOW_DEFAULT_VAR.set(allowDefault.and(ALLOW_DEFAULT_VAR)).toStmt()); |
| } |
| var _c = elementEventNameAndTarget(eventAst, dirAst), eventTarget = _c.target, eventName = _c.name; |
| var fullEventName = elementEventFullName(eventTarget, eventName); |
| handleEventStmts.push(applySourceSpanToStatementIfNeeded(new IfStmt(literal(fullEventName).identical(EVENT_NAME_VAR), trueStmts), eventAst.sourceSpan)); |
| }); |
| var handleEventFn; |
| if (handleEventStmts.length > 0) { |
| var preStmts = [ALLOW_DEFAULT_VAR.set(literal(true)).toDeclStmt(BOOL_TYPE)]; |
| if (!this.component.isHost && findReadVarNames(handleEventStmts).has(COMP_VAR.name)) { |
| preStmts.push(COMP_VAR.set(VIEW_VAR.prop('component')).toDeclStmt(this.compType)); |
| } |
| handleEventFn = fn([ |
| new FnParam(VIEW_VAR.name, INFERRED_TYPE), |
| new FnParam(EVENT_NAME_VAR.name, INFERRED_TYPE), |
| new FnParam(EventHandlerVars.event.name, INFERRED_TYPE) |
| ], __spread(preStmts, handleEventStmts, [new ReturnStatement(ALLOW_DEFAULT_VAR)]), INFERRED_TYPE); |
| } |
| else { |
| handleEventFn = NULL_EXPR; |
| } |
| return handleEventFn; |
| }; |
| ViewBuilder.prototype.visitDirective = function (ast, context) { }; |
| ViewBuilder.prototype.visitDirectiveProperty = function (ast, context) { }; |
| ViewBuilder.prototype.visitReference = function (ast, context) { }; |
| ViewBuilder.prototype.visitVariable = function (ast, context) { }; |
| ViewBuilder.prototype.visitEvent = function (ast, context) { }; |
| ViewBuilder.prototype.visitElementProperty = function (ast, context) { }; |
| ViewBuilder.prototype.visitAttr = function (ast, context) { }; |
| return ViewBuilder; |
| }()); |
| function needsAdditionalRootNode(astNodes) { |
| var lastAstNode = astNodes[astNodes.length - 1]; |
| if (lastAstNode instanceof EmbeddedTemplateAst) { |
| return lastAstNode.hasViewContainer; |
| } |
| if (lastAstNode instanceof ElementAst) { |
| if (isNgContainer(lastAstNode.name) && lastAstNode.children.length) { |
| return needsAdditionalRootNode(lastAstNode.children); |
| } |
| return lastAstNode.hasViewContainer; |
| } |
| return lastAstNode instanceof NgContentAst; |
| } |
| function elementBindingDef(inputAst, dirAst) { |
| var inputType = inputAst.type; |
| switch (inputType) { |
| case 1 /* Attribute */: |
| return literalArr([ |
| literal(1 /* TypeElementAttribute */), literal(inputAst.name), |
| literal(inputAst.securityContext) |
| ]); |
| case 0 /* Property */: |
| return literalArr([ |
| literal(8 /* TypeProperty */), literal(inputAst.name), |
| literal(inputAst.securityContext) |
| ]); |
| case 4 /* Animation */: |
| var bindingType = 8 /* TypeProperty */ | |
| (dirAst && dirAst.directive.isComponent ? 32 /* SyntheticHostProperty */ : |
| 16 /* SyntheticProperty */); |
| return literalArr([ |
| literal(bindingType), literal('@' + inputAst.name), literal(inputAst.securityContext) |
| ]); |
| case 2 /* Class */: |
| return literalArr([literal(2 /* TypeElementClass */), literal(inputAst.name), NULL_EXPR]); |
| case 3 /* Style */: |
| return literalArr([ |
| literal(4 /* TypeElementStyle */), literal(inputAst.name), literal(inputAst.unit) |
| ]); |
| default: |
| // This default case is not needed by TypeScript compiler, as the switch is exhaustive. |
| // However Closure Compiler does not understand that and reports an error in typed mode. |
| // The `throw new Error` below works around the problem, and the unexpected: never variable |
| // makes sure tsc still checks this code is unreachable. |
| var unexpected = inputType; |
| throw new Error("unexpected " + unexpected); |
| } |
| } |
| function fixedAttrsDef(elementAst) { |
| var mapResult = Object.create(null); |
| elementAst.attrs.forEach(function (attrAst) { mapResult[attrAst.name] = attrAst.value; }); |
| elementAst.directives.forEach(function (dirAst) { |
| Object.keys(dirAst.directive.hostAttributes).forEach(function (name) { |
| var value = dirAst.directive.hostAttributes[name]; |
| var prevValue = mapResult[name]; |
| mapResult[name] = prevValue != null ? mergeAttributeValue(name, prevValue, value) : value; |
| }); |
| }); |
| // Note: We need to sort to get a defined output order |
| // for tests and for caching generated artifacts... |
| return literalArr(Object.keys(mapResult).sort().map(function (attrName) { return literalArr([literal(attrName), literal(mapResult[attrName])]); })); |
| } |
| function mergeAttributeValue(attrName, attrValue1, attrValue2) { |
| if (attrName == CLASS_ATTR$1 || attrName == STYLE_ATTR) { |
| return attrValue1 + " " + attrValue2; |
| } |
| else { |
| return attrValue2; |
| } |
| } |
| function callCheckStmt(nodeIndex, exprs) { |
| if (exprs.length > 10) { |
| return CHECK_VAR.callFn([VIEW_VAR, literal(nodeIndex), literal(1 /* Dynamic */), literalArr(exprs)]); |
| } |
| else { |
| return CHECK_VAR.callFn(__spread([VIEW_VAR, literal(nodeIndex), literal(0 /* Inline */)], exprs)); |
| } |
| } |
| function callUnwrapValue(nodeIndex, bindingIdx, expr) { |
| return importExpr(Identifiers.unwrapValue).callFn([ |
| VIEW_VAR, literal(nodeIndex), literal(bindingIdx), expr |
| ]); |
| } |
| function findStaticQueryIds(nodes, result) { |
| if (result === void 0) { result = new Map(); } |
| nodes.forEach(function (node) { |
| var staticQueryIds = new Set(); |
| var dynamicQueryIds = new Set(); |
| var queryMatches = undefined; |
| if (node instanceof ElementAst) { |
| findStaticQueryIds(node.children, result); |
| node.children.forEach(function (child) { |
| var childData = result.get(child); |
| childData.staticQueryIds.forEach(function (queryId) { return staticQueryIds.add(queryId); }); |
| childData.dynamicQueryIds.forEach(function (queryId) { return dynamicQueryIds.add(queryId); }); |
| }); |
| queryMatches = node.queryMatches; |
| } |
| else if (node instanceof EmbeddedTemplateAst) { |
| findStaticQueryIds(node.children, result); |
| node.children.forEach(function (child) { |
| var childData = result.get(child); |
| childData.staticQueryIds.forEach(function (queryId) { return dynamicQueryIds.add(queryId); }); |
| childData.dynamicQueryIds.forEach(function (queryId) { return dynamicQueryIds.add(queryId); }); |
| }); |
| queryMatches = node.queryMatches; |
| } |
| if (queryMatches) { |
| queryMatches.forEach(function (match) { return staticQueryIds.add(match.queryId); }); |
| } |
| dynamicQueryIds.forEach(function (queryId) { return staticQueryIds.delete(queryId); }); |
| result.set(node, { staticQueryIds: staticQueryIds, dynamicQueryIds: dynamicQueryIds }); |
| }); |
| return result; |
| } |
| function staticViewQueryIds(nodeStaticQueryIds) { |
| var staticQueryIds = new Set(); |
| var dynamicQueryIds = new Set(); |
| Array.from(nodeStaticQueryIds.values()).forEach(function (entry) { |
| entry.staticQueryIds.forEach(function (queryId) { return staticQueryIds.add(queryId); }); |
| entry.dynamicQueryIds.forEach(function (queryId) { return dynamicQueryIds.add(queryId); }); |
| }); |
| dynamicQueryIds.forEach(function (queryId) { return staticQueryIds.delete(queryId); }); |
| return { staticQueryIds: staticQueryIds, dynamicQueryIds: dynamicQueryIds }; |
| } |
| function elementEventNameAndTarget(eventAst, dirAst) { |
| if (eventAst.isAnimation) { |
| return { |
| name: "@" + eventAst.name + "." + eventAst.phase, |
| target: dirAst && dirAst.directive.isComponent ? 'component' : null |
| }; |
| } |
| else { |
| return eventAst; |
| } |
| } |
| function calcStaticDynamicQueryFlags(queryIds, queryId, query) { |
| var flags = 0 /* None */; |
| // Note: We only make queries static that query for a single item. |
| // This is because of backwards compatibility with the old view compiler... |
| if (query.first && shouldResolveAsStaticQuery(queryIds, queryId, query)) { |
| flags |= 268435456 /* StaticQuery */; |
| } |
| else { |
| flags |= 536870912 /* DynamicQuery */; |
| } |
| return flags; |
| } |
| function shouldResolveAsStaticQuery(queryIds, queryId, query) { |
| // If query.static has been set by the user, use that value to determine whether |
| // the query is static. If none has been set, sort the query into static/dynamic |
| // based on query results (i.e. dynamic if CD needs to run to get all results). |
| return query.static || |
| query.static == null && |
| (queryIds.staticQueryIds.has(queryId) || !queryIds.dynamicQueryIds.has(queryId)); |
| } |
| function elementEventFullName(target, name) { |
| return target ? target + ":" + name : name; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * A container for message extracted from the templates. |
| */ |
| var MessageBundle = /** @class */ (function () { |
| function MessageBundle(_htmlParser, _implicitTags, _implicitAttrs, _locale) { |
| if (_locale === void 0) { _locale = null; } |
| this._htmlParser = _htmlParser; |
| this._implicitTags = _implicitTags; |
| this._implicitAttrs = _implicitAttrs; |
| this._locale = _locale; |
| this._messages = []; |
| } |
| MessageBundle.prototype.updateFromTemplate = function (html, url, interpolationConfig) { |
| var _a; |
| var htmlParserResult = this._htmlParser.parse(html, url, { tokenizeExpansionForms: true, interpolationConfig: interpolationConfig }); |
| if (htmlParserResult.errors.length) { |
| return htmlParserResult.errors; |
| } |
| var i18nParserResult = extractMessages(htmlParserResult.rootNodes, interpolationConfig, this._implicitTags, this._implicitAttrs); |
| if (i18nParserResult.errors.length) { |
| return i18nParserResult.errors; |
| } |
| (_a = this._messages).push.apply(_a, __spread(i18nParserResult.messages)); |
| return []; |
| }; |
| // Return the message in the internal format |
| // The public (serialized) format might be different, see the `write` method. |
| MessageBundle.prototype.getMessages = function () { return this._messages; }; |
| MessageBundle.prototype.write = function (serializer, filterSources) { |
| var messages = {}; |
| var mapperVisitor = new MapPlaceholderNames(); |
| // Deduplicate messages based on their ID |
| this._messages.forEach(function (message) { |
| var _a; |
| var id = serializer.digest(message); |
| if (!messages.hasOwnProperty(id)) { |
| messages[id] = message; |
| } |
| else { |
| (_a = messages[id].sources).push.apply(_a, __spread(message.sources)); |
| } |
| }); |
| // Transform placeholder names using the serializer mapping |
| var msgList = Object.keys(messages).map(function (id) { |
| var mapper = serializer.createNameMapper(messages[id]); |
| var src = messages[id]; |
| var nodes = mapper ? mapperVisitor.convert(src.nodes, mapper) : src.nodes; |
| var transformedMessage = new Message(nodes, {}, {}, src.meaning, src.description, id); |
| transformedMessage.sources = src.sources; |
| if (filterSources) { |
| transformedMessage.sources.forEach(function (source) { return source.filePath = filterSources(source.filePath); }); |
| } |
| return transformedMessage; |
| }); |
| return serializer.write(msgList, this._locale); |
| }; |
| return MessageBundle; |
| }()); |
| // Transform an i18n AST by renaming the placeholder nodes with the given mapper |
| var MapPlaceholderNames = /** @class */ (function (_super) { |
| __extends(MapPlaceholderNames, _super); |
| function MapPlaceholderNames() { |
| return _super !== null && _super.apply(this, arguments) || this; |
| } |
| MapPlaceholderNames.prototype.convert = function (nodes, mapper) { |
| var _this = this; |
| return mapper ? nodes.map(function (n) { return n.visit(_this, mapper); }) : nodes; |
| }; |
| MapPlaceholderNames.prototype.visitTagPlaceholder = function (ph, mapper) { |
| var _this = this; |
| var startName = mapper.toPublicName(ph.startName); |
| var closeName = ph.closeName ? mapper.toPublicName(ph.closeName) : ph.closeName; |
| var children = ph.children.map(function (n) { return n.visit(_this, mapper); }); |
| return new TagPlaceholder(ph.tag, ph.attrs, startName, closeName, children, ph.isVoid, ph.sourceSpan); |
| }; |
| MapPlaceholderNames.prototype.visitPlaceholder = function (ph, mapper) { |
| return new Placeholder(ph.value, mapper.toPublicName(ph.name), ph.sourceSpan); |
| }; |
| MapPlaceholderNames.prototype.visitIcuPlaceholder = function (ph, mapper) { |
| return new IcuPlaceholder(ph.value, mapper.toPublicName(ph.name), ph.sourceSpan); |
| }; |
| return MapPlaceholderNames; |
| }(CloneVisitor)); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var GeneratedFile = /** @class */ (function () { |
| function GeneratedFile(srcFileUrl, genFileUrl, sourceOrStmts) { |
| this.srcFileUrl = srcFileUrl; |
| this.genFileUrl = genFileUrl; |
| if (typeof sourceOrStmts === 'string') { |
| this.source = sourceOrStmts; |
| this.stmts = null; |
| } |
| else { |
| this.source = null; |
| this.stmts = sourceOrStmts; |
| } |
| } |
| GeneratedFile.prototype.isEquivalent = function (other) { |
| if (this.genFileUrl !== other.genFileUrl) { |
| return false; |
| } |
| if (this.source) { |
| return this.source === other.source; |
| } |
| if (other.stmts == null) { |
| return false; |
| } |
| // Note: the constructor guarantees that if this.source is not filled, |
| // then this.stmts is. |
| return areAllEquivalent(this.stmts, other.stmts); |
| }; |
| return GeneratedFile; |
| }()); |
| function toTypeScript(file, preamble) { |
| if (preamble === void 0) { preamble = ''; } |
| if (!file.stmts) { |
| throw new Error("Illegal state: No stmts present on GeneratedFile " + file.genFileUrl); |
| } |
| return new TypeScriptEmitter().emitStatements(file.genFileUrl, file.stmts, preamble); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| function listLazyRoutes(moduleMeta, reflector) { |
| var e_1, _a, e_2, _b; |
| var allLazyRoutes = []; |
| try { |
| for (var _c = __values(moduleMeta.transitiveModule.providers), _d = _c.next(); !_d.done; _d = _c.next()) { |
| var _e = _d.value, provider = _e.provider, module = _e.module; |
| if (tokenReference(provider.token) === reflector.ROUTES) { |
| var loadChildren = _collectLoadChildren(provider.useValue); |
| try { |
| for (var loadChildren_1 = __values(loadChildren), loadChildren_1_1 = loadChildren_1.next(); !loadChildren_1_1.done; loadChildren_1_1 = loadChildren_1.next()) { |
| var route = loadChildren_1_1.value; |
| allLazyRoutes.push(parseLazyRoute(route, reflector, module.reference)); |
| } |
| } |
| catch (e_2_1) { e_2 = { error: e_2_1 }; } |
| finally { |
| try { |
| if (loadChildren_1_1 && !loadChildren_1_1.done && (_b = loadChildren_1.return)) _b.call(loadChildren_1); |
| } |
| finally { if (e_2) throw e_2.error; } |
| } |
| } |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (_d && !_d.done && (_a = _c.return)) _a.call(_c); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| return allLazyRoutes; |
| } |
| function _collectLoadChildren(routes, target) { |
| var e_3, _a; |
| if (target === void 0) { target = []; } |
| if (typeof routes === 'string') { |
| target.push(routes); |
| } |
| else if (Array.isArray(routes)) { |
| try { |
| for (var routes_1 = __values(routes), routes_1_1 = routes_1.next(); !routes_1_1.done; routes_1_1 = routes_1.next()) { |
| var route = routes_1_1.value; |
| _collectLoadChildren(route, target); |
| } |
| } |
| catch (e_3_1) { e_3 = { error: e_3_1 }; } |
| finally { |
| try { |
| if (routes_1_1 && !routes_1_1.done && (_a = routes_1.return)) _a.call(routes_1); |
| } |
| finally { if (e_3) throw e_3.error; } |
| } |
| } |
| else if (routes.loadChildren) { |
| _collectLoadChildren(routes.loadChildren, target); |
| } |
| else if (routes.children) { |
| _collectLoadChildren(routes.children, target); |
| } |
| return target; |
| } |
| function parseLazyRoute(route, reflector, module) { |
| var _a = __read(route.split('#'), 2), routePath = _a[0], routeName = _a[1]; |
| var referencedModule = reflector.resolveExternalReference({ |
| moduleName: routePath, |
| name: routeName, |
| }, module ? module.filePath : undefined); |
| return { route: route, module: module || referencedModule, referencedModule: referencedModule }; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var TS = /^(?!.*\.d\.ts$).*\.ts$/; |
| var ResolvedStaticSymbol = /** @class */ (function () { |
| function ResolvedStaticSymbol(symbol, metadata) { |
| this.symbol = symbol; |
| this.metadata = metadata; |
| } |
| return ResolvedStaticSymbol; |
| }()); |
| var SUPPORTED_SCHEMA_VERSION = 4; |
| /** |
| * This class is responsible for loading metadata per symbol, |
| * and normalizing references between symbols. |
| * |
| * Internally, it only uses symbols without members, |
| * and deduces the values for symbols with members based |
| * on these symbols. |
| */ |
| var StaticSymbolResolver = /** @class */ (function () { |
| function StaticSymbolResolver(host, staticSymbolCache, summaryResolver, errorRecorder) { |
| this.host = host; |
| this.staticSymbolCache = staticSymbolCache; |
| this.summaryResolver = summaryResolver; |
| this.errorRecorder = errorRecorder; |
| this.metadataCache = new Map(); |
| // Note: this will only contain StaticSymbols without members! |
| this.resolvedSymbols = new Map(); |
| this.resolvedFilePaths = new Set(); |
| // Note: this will only contain StaticSymbols without members! |
| this.importAs = new Map(); |
| this.symbolResourcePaths = new Map(); |
| this.symbolFromFile = new Map(); |
| this.knownFileNameToModuleNames = new Map(); |
| } |
| StaticSymbolResolver.prototype.resolveSymbol = function (staticSymbol) { |
| if (staticSymbol.members.length > 0) { |
| return this._resolveSymbolMembers(staticSymbol); |
| } |
| // Note: always ask for a summary first, |
| // as we might have read shallow metadata via a .d.ts file |
| // for the symbol. |
| var resultFromSummary = this._resolveSymbolFromSummary(staticSymbol); |
| if (resultFromSummary) { |
| return resultFromSummary; |
| } |
| var resultFromCache = this.resolvedSymbols.get(staticSymbol); |
| if (resultFromCache) { |
| return resultFromCache; |
| } |
| // Note: Some users use libraries that were not compiled with ngc, i.e. they don't |
| // have summaries, only .d.ts files. So we always need to check both, the summary |
| // and metadata. |
| this._createSymbolsOf(staticSymbol.filePath); |
| return this.resolvedSymbols.get(staticSymbol); |
| }; |
| /** |
| * getImportAs produces a symbol that can be used to import the given symbol. |
| * The import might be different than the symbol if the symbol is exported from |
| * a library with a summary; in which case we want to import the symbol from the |
| * ngfactory re-export instead of directly to avoid introducing a direct dependency |
| * on an otherwise indirect dependency. |
| * |
| * @param staticSymbol the symbol for which to generate a import symbol |
| */ |
| StaticSymbolResolver.prototype.getImportAs = function (staticSymbol, useSummaries) { |
| if (useSummaries === void 0) { useSummaries = true; } |
| if (staticSymbol.members.length) { |
| var baseSymbol = this.getStaticSymbol(staticSymbol.filePath, staticSymbol.name); |
| var baseImportAs = this.getImportAs(baseSymbol, useSummaries); |
| return baseImportAs ? |
| this.getStaticSymbol(baseImportAs.filePath, baseImportAs.name, staticSymbol.members) : |
| null; |
| } |
| var summarizedFileName = stripSummaryForJitFileSuffix(staticSymbol.filePath); |
| if (summarizedFileName !== staticSymbol.filePath) { |
| var summarizedName = stripSummaryForJitNameSuffix(staticSymbol.name); |
| var baseSymbol = this.getStaticSymbol(summarizedFileName, summarizedName, staticSymbol.members); |
| var baseImportAs = this.getImportAs(baseSymbol, useSummaries); |
| return baseImportAs ? |
| this.getStaticSymbol(summaryForJitFileName(baseImportAs.filePath), summaryForJitName(baseImportAs.name), baseSymbol.members) : |
| null; |
| } |
| var result = (useSummaries && this.summaryResolver.getImportAs(staticSymbol)) || null; |
| if (!result) { |
| result = this.importAs.get(staticSymbol); |
| } |
| return result; |
| }; |
| /** |
| * getResourcePath produces the path to the original location of the symbol and should |
| * be used to determine the relative location of resource references recorded in |
| * symbol metadata. |
| */ |
| StaticSymbolResolver.prototype.getResourcePath = function (staticSymbol) { |
| return this.symbolResourcePaths.get(staticSymbol) || staticSymbol.filePath; |
| }; |
| /** |
| * getTypeArity returns the number of generic type parameters the given symbol |
| * has. If the symbol is not a type the result is null. |
| */ |
| StaticSymbolResolver.prototype.getTypeArity = function (staticSymbol) { |
| // If the file is a factory/ngsummary file, don't resolve the symbol as doing so would |
| // cause the metadata for an factory/ngsummary file to be loaded which doesn't exist. |
| // All references to generated classes must include the correct arity whenever |
| // generating code. |
| if (isGeneratedFile(staticSymbol.filePath)) { |
| return null; |
| } |
| var resolvedSymbol = unwrapResolvedMetadata(this.resolveSymbol(staticSymbol)); |
| while (resolvedSymbol && resolvedSymbol.metadata instanceof StaticSymbol) { |
| resolvedSymbol = unwrapResolvedMetadata(this.resolveSymbol(resolvedSymbol.metadata)); |
| } |
| return (resolvedSymbol && resolvedSymbol.metadata && resolvedSymbol.metadata.arity) || null; |
| }; |
| StaticSymbolResolver.prototype.getKnownModuleName = function (filePath) { |
| return this.knownFileNameToModuleNames.get(filePath) || null; |
| }; |
| StaticSymbolResolver.prototype.recordImportAs = function (sourceSymbol, targetSymbol) { |
| sourceSymbol.assertNoMembers(); |
| targetSymbol.assertNoMembers(); |
| this.importAs.set(sourceSymbol, targetSymbol); |
| }; |
| StaticSymbolResolver.prototype.recordModuleNameForFileName = function (fileName, moduleName) { |
| this.knownFileNameToModuleNames.set(fileName, moduleName); |
| }; |
| /** |
| * Invalidate all information derived from the given file. |
| * |
| * @param fileName the file to invalidate |
| */ |
| StaticSymbolResolver.prototype.invalidateFile = function (fileName) { |
| var e_1, _a; |
| this.metadataCache.delete(fileName); |
| this.resolvedFilePaths.delete(fileName); |
| var symbols = this.symbolFromFile.get(fileName); |
| if (symbols) { |
| this.symbolFromFile.delete(fileName); |
| try { |
| for (var symbols_1 = __values(symbols), symbols_1_1 = symbols_1.next(); !symbols_1_1.done; symbols_1_1 = symbols_1.next()) { |
| var symbol = symbols_1_1.value; |
| this.resolvedSymbols.delete(symbol); |
| this.importAs.delete(symbol); |
| this.symbolResourcePaths.delete(symbol); |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (symbols_1_1 && !symbols_1_1.done && (_a = symbols_1.return)) _a.call(symbols_1); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| } |
| }; |
| /** @internal */ |
| StaticSymbolResolver.prototype.ignoreErrorsFor = function (cb) { |
| var recorder = this.errorRecorder; |
| this.errorRecorder = function () { }; |
| try { |
| return cb(); |
| } |
| finally { |
| this.errorRecorder = recorder; |
| } |
| }; |
| StaticSymbolResolver.prototype._resolveSymbolMembers = function (staticSymbol) { |
| var members = staticSymbol.members; |
| var baseResolvedSymbol = this.resolveSymbol(this.getStaticSymbol(staticSymbol.filePath, staticSymbol.name)); |
| if (!baseResolvedSymbol) { |
| return null; |
| } |
| var baseMetadata = unwrapResolvedMetadata(baseResolvedSymbol.metadata); |
| if (baseMetadata instanceof StaticSymbol) { |
| return new ResolvedStaticSymbol(staticSymbol, this.getStaticSymbol(baseMetadata.filePath, baseMetadata.name, members)); |
| } |
| else if (baseMetadata && baseMetadata.__symbolic === 'class') { |
| if (baseMetadata.statics && members.length === 1) { |
| return new ResolvedStaticSymbol(staticSymbol, baseMetadata.statics[members[0]]); |
| } |
| } |
| else { |
| var value = baseMetadata; |
| for (var i = 0; i < members.length && value; i++) { |
| value = value[members[i]]; |
| } |
| return new ResolvedStaticSymbol(staticSymbol, value); |
| } |
| return null; |
| }; |
| StaticSymbolResolver.prototype._resolveSymbolFromSummary = function (staticSymbol) { |
| var summary = this.summaryResolver.resolveSummary(staticSymbol); |
| return summary ? new ResolvedStaticSymbol(staticSymbol, summary.metadata) : null; |
| }; |
| /** |
| * getStaticSymbol produces a Type whose metadata is known but whose implementation is not loaded. |
| * All types passed to the StaticResolver should be pseudo-types returned by this method. |
| * |
| * @param declarationFile the absolute path of the file where the symbol is declared |
| * @param name the name of the type. |
| * @param members a symbol for a static member of the named type |
| */ |
| StaticSymbolResolver.prototype.getStaticSymbol = function (declarationFile, name, members) { |
| return this.staticSymbolCache.get(declarationFile, name, members); |
| }; |
| /** |
| * hasDecorators checks a file's metadata for the presence of decorators without evaluating the |
| * metadata. |
| * |
| * @param filePath the absolute path to examine for decorators. |
| * @returns true if any class in the file has a decorator. |
| */ |
| StaticSymbolResolver.prototype.hasDecorators = function (filePath) { |
| var metadata = this.getModuleMetadata(filePath); |
| if (metadata['metadata']) { |
| return Object.keys(metadata['metadata']).some(function (metadataKey) { |
| var entry = metadata['metadata'][metadataKey]; |
| return entry && entry.__symbolic === 'class' && entry.decorators; |
| }); |
| } |
| return false; |
| }; |
| StaticSymbolResolver.prototype.getSymbolsOf = function (filePath) { |
| var summarySymbols = this.summaryResolver.getSymbolsOf(filePath); |
| if (summarySymbols) { |
| return summarySymbols; |
| } |
| // Note: Some users use libraries that were not compiled with ngc, i.e. they don't |
| // have summaries, only .d.ts files, but `summaryResolver.isLibraryFile` returns true. |
| this._createSymbolsOf(filePath); |
| var metadataSymbols = []; |
| this.resolvedSymbols.forEach(function (resolvedSymbol) { |
| if (resolvedSymbol.symbol.filePath === filePath) { |
| metadataSymbols.push(resolvedSymbol.symbol); |
| } |
| }); |
| return metadataSymbols; |
| }; |
| StaticSymbolResolver.prototype._createSymbolsOf = function (filePath) { |
| var _this = this; |
| var e_2, _a; |
| if (this.resolvedFilePaths.has(filePath)) { |
| return; |
| } |
| this.resolvedFilePaths.add(filePath); |
| var resolvedSymbols = []; |
| var metadata = this.getModuleMetadata(filePath); |
| if (metadata['importAs']) { |
| // Index bundle indices should use the importAs module name defined |
| // in the bundle. |
| this.knownFileNameToModuleNames.set(filePath, metadata['importAs']); |
| } |
| // handle the symbols in one of the re-export location |
| if (metadata['exports']) { |
| var _loop_1 = function (moduleExport) { |
| // handle the symbols in the list of explicitly re-exported symbols. |
| if (moduleExport.export) { |
| moduleExport.export.forEach(function (exportSymbol) { |
| var symbolName; |
| if (typeof exportSymbol === 'string') { |
| symbolName = exportSymbol; |
| } |
| else { |
| symbolName = exportSymbol.as; |
| } |
| symbolName = unescapeIdentifier(symbolName); |
| var symName = symbolName; |
| if (typeof exportSymbol !== 'string') { |
| symName = unescapeIdentifier(exportSymbol.name); |
| } |
| var resolvedModule = _this.resolveModule(moduleExport.from, filePath); |
| if (resolvedModule) { |
| var targetSymbol = _this.getStaticSymbol(resolvedModule, symName); |
| var sourceSymbol = _this.getStaticSymbol(filePath, symbolName); |
| resolvedSymbols.push(_this.createExport(sourceSymbol, targetSymbol)); |
| } |
| }); |
| } |
| else { |
| // handle the symbols via export * directives. |
| var resolvedModule = this_1.resolveModule(moduleExport.from, filePath); |
| if (resolvedModule) { |
| var nestedExports = this_1.getSymbolsOf(resolvedModule); |
| nestedExports.forEach(function (targetSymbol) { |
| var sourceSymbol = _this.getStaticSymbol(filePath, targetSymbol.name); |
| resolvedSymbols.push(_this.createExport(sourceSymbol, targetSymbol)); |
| }); |
| } |
| } |
| }; |
| var this_1 = this; |
| try { |
| for (var _b = __values(metadata['exports']), _c = _b.next(); !_c.done; _c = _b.next()) { |
| var moduleExport = _c.value; |
| _loop_1(moduleExport); |
| } |
| } |
| catch (e_2_1) { e_2 = { error: e_2_1 }; } |
| finally { |
| try { |
| if (_c && !_c.done && (_a = _b.return)) _a.call(_b); |
| } |
| finally { if (e_2) throw e_2.error; } |
| } |
| } |
| // handle the actual metadata. Has to be after the exports |
| // as there might be collisions in the names, and we want the symbols |
| // of the current module to win ofter reexports. |
| if (metadata['metadata']) { |
| // handle direct declarations of the symbol |
| var topLevelSymbolNames_1 = new Set(Object.keys(metadata['metadata']).map(unescapeIdentifier)); |
| var origins_1 = metadata['origins'] || {}; |
| Object.keys(metadata['metadata']).forEach(function (metadataKey) { |
| var symbolMeta = metadata['metadata'][metadataKey]; |
| var name = unescapeIdentifier(metadataKey); |
| var symbol = _this.getStaticSymbol(filePath, name); |
| var origin = origins_1.hasOwnProperty(metadataKey) && origins_1[metadataKey]; |
| if (origin) { |
| // If the symbol is from a bundled index, use the declaration location of the |
| // symbol so relative references (such as './my.html') will be calculated |
| // correctly. |
| var originFilePath = _this.resolveModule(origin, filePath); |
| if (!originFilePath) { |
| _this.reportError(new Error("Couldn't resolve original symbol for " + origin + " from " + _this.host.getOutputName(filePath))); |
| } |
| else { |
| _this.symbolResourcePaths.set(symbol, originFilePath); |
| } |
| } |
| resolvedSymbols.push(_this.createResolvedSymbol(symbol, filePath, topLevelSymbolNames_1, symbolMeta)); |
| }); |
| } |
| resolvedSymbols.forEach(function (resolvedSymbol) { return _this.resolvedSymbols.set(resolvedSymbol.symbol, resolvedSymbol); }); |
| this.symbolFromFile.set(filePath, resolvedSymbols.map(function (resolvedSymbol) { return resolvedSymbol.symbol; })); |
| }; |
| StaticSymbolResolver.prototype.createResolvedSymbol = function (sourceSymbol, topLevelPath, topLevelSymbolNames, metadata) { |
| var _this = this; |
| // For classes that don't have Angular summaries / metadata, |
| // we only keep their arity, but nothing else |
| // (e.g. their constructor parameters). |
| // We do this to prevent introducing deep imports |
| // as we didn't generate .ngfactory.ts files with proper reexports. |
| var isTsFile = TS.test(sourceSymbol.filePath); |
| if (this.summaryResolver.isLibraryFile(sourceSymbol.filePath) && !isTsFile && metadata && |
| metadata['__symbolic'] === 'class') { |
| var transformedMeta_1 = { __symbolic: 'class', arity: metadata.arity }; |
| return new ResolvedStaticSymbol(sourceSymbol, transformedMeta_1); |
| } |
| var _originalFileMemo; |
| var getOriginalName = function () { |
| if (!_originalFileMemo) { |
| // Guess what the original file name is from the reference. If it has a `.d.ts` extension |
| // replace it with `.ts`. If it already has `.ts` just leave it in place. If it doesn't have |
| // .ts or .d.ts, append `.ts'. Also, if it is in `node_modules`, trim the `node_module` |
| // location as it is not important to finding the file. |
| _originalFileMemo = |
| _this.host.getOutputName(topLevelPath.replace(/((\.ts)|(\.d\.ts)|)$/, '.ts') |
| .replace(/^.*node_modules[/\\]/, '')); |
| } |
| return _originalFileMemo; |
| }; |
| var self = this; |
| var ReferenceTransformer = /** @class */ (function (_super) { |
| __extends(ReferenceTransformer, _super); |
| function ReferenceTransformer() { |
| return _super !== null && _super.apply(this, arguments) || this; |
| } |
| ReferenceTransformer.prototype.visitStringMap = function (map, functionParams) { |
| var symbolic = map['__symbolic']; |
| if (symbolic === 'function') { |
| var oldLen = functionParams.length; |
| functionParams.push.apply(functionParams, __spread((map['parameters'] || []))); |
| var result = _super.prototype.visitStringMap.call(this, map, functionParams); |
| functionParams.length = oldLen; |
| return result; |
| } |
| else if (symbolic === 'reference') { |
| var module = map['module']; |
| var name_1 = map['name'] ? unescapeIdentifier(map['name']) : map['name']; |
| if (!name_1) { |
| return null; |
| } |
| var filePath = void 0; |
| if (module) { |
| filePath = self.resolveModule(module, sourceSymbol.filePath); |
| if (!filePath) { |
| return { |
| __symbolic: 'error', |
| message: "Could not resolve " + module + " relative to " + self.host.getMetadataFor(sourceSymbol.filePath) + ".", |
| line: map['line'], |
| character: map['character'], |
| fileName: getOriginalName() |
| }; |
| } |
| return { |
| __symbolic: 'resolved', |
| symbol: self.getStaticSymbol(filePath, name_1), |
| line: map['line'], |
| character: map['character'], |
| fileName: getOriginalName() |
| }; |
| } |
| else if (functionParams.indexOf(name_1) >= 0) { |
| // reference to a function parameter |
| return { __symbolic: 'reference', name: name_1 }; |
| } |
| else { |
| if (topLevelSymbolNames.has(name_1)) { |
| return self.getStaticSymbol(topLevelPath, name_1); |
| } |
| } |
| } |
| else if (symbolic === 'error') { |
| return __assign({}, map, { fileName: getOriginalName() }); |
| } |
| else { |
| return _super.prototype.visitStringMap.call(this, map, functionParams); |
| } |
| }; |
| return ReferenceTransformer; |
| }(ValueTransformer)); |
| var transformedMeta = visitValue(metadata, new ReferenceTransformer(), []); |
| var unwrappedTransformedMeta = unwrapResolvedMetadata(transformedMeta); |
| if (unwrappedTransformedMeta instanceof StaticSymbol) { |
| return this.createExport(sourceSymbol, unwrappedTransformedMeta); |
| } |
| return new ResolvedStaticSymbol(sourceSymbol, transformedMeta); |
| }; |
| StaticSymbolResolver.prototype.createExport = function (sourceSymbol, targetSymbol) { |
| sourceSymbol.assertNoMembers(); |
| targetSymbol.assertNoMembers(); |
| if (this.summaryResolver.isLibraryFile(sourceSymbol.filePath) && |
| this.summaryResolver.isLibraryFile(targetSymbol.filePath)) { |
| // This case is for an ng library importing symbols from a plain ts library |
| // transitively. |
| // Note: We rely on the fact that we discover symbols in the direction |
| // from source files to library files |
| this.importAs.set(targetSymbol, this.getImportAs(sourceSymbol) || sourceSymbol); |
| } |
| return new ResolvedStaticSymbol(sourceSymbol, targetSymbol); |
| }; |
| StaticSymbolResolver.prototype.reportError = function (error, context, path) { |
| if (this.errorRecorder) { |
| this.errorRecorder(error, (context && context.filePath) || path); |
| } |
| else { |
| throw error; |
| } |
| }; |
| /** |
| * @param module an absolute path to a module file. |
| */ |
| StaticSymbolResolver.prototype.getModuleMetadata = function (module) { |
| var moduleMetadata = this.metadataCache.get(module); |
| if (!moduleMetadata) { |
| var moduleMetadatas = this.host.getMetadataFor(module); |
| if (moduleMetadatas) { |
| var maxVersion_1 = -1; |
| moduleMetadatas.forEach(function (md) { |
| if (md && md['version'] > maxVersion_1) { |
| maxVersion_1 = md['version']; |
| moduleMetadata = md; |
| } |
| }); |
| } |
| if (!moduleMetadata) { |
| moduleMetadata = |
| { __symbolic: 'module', version: SUPPORTED_SCHEMA_VERSION, module: module, metadata: {} }; |
| } |
| if (moduleMetadata['version'] != SUPPORTED_SCHEMA_VERSION) { |
| var errorMessage = moduleMetadata['version'] == 2 ? |
| "Unsupported metadata version " + moduleMetadata['version'] + " for module " + module + ". This module should be compiled with a newer version of ngc" : |
| "Metadata version mismatch for module " + this.host.getOutputName(module) + ", found version " + moduleMetadata['version'] + ", expected " + SUPPORTED_SCHEMA_VERSION; |
| this.reportError(new Error(errorMessage)); |
| } |
| this.metadataCache.set(module, moduleMetadata); |
| } |
| return moduleMetadata; |
| }; |
| StaticSymbolResolver.prototype.getSymbolByModule = function (module, symbolName, containingFile) { |
| var filePath = this.resolveModule(module, containingFile); |
| if (!filePath) { |
| this.reportError(new Error("Could not resolve module " + module + (containingFile ? ' relative to ' + |
| this.host.getOutputName(containingFile) : ''))); |
| return this.getStaticSymbol("ERROR:" + module, symbolName); |
| } |
| return this.getStaticSymbol(filePath, symbolName); |
| }; |
| StaticSymbolResolver.prototype.resolveModule = function (module, containingFile) { |
| try { |
| return this.host.moduleNameToFileName(module, containingFile); |
| } |
| catch (e) { |
| console.error("Could not resolve module '" + module + "' relative to file " + containingFile); |
| this.reportError(e, undefined, containingFile); |
| } |
| return null; |
| }; |
| return StaticSymbolResolver; |
| }()); |
| // Remove extra underscore from escaped identifier. |
| // See https://github.com/Microsoft/TypeScript/blob/master/src/compiler/utilities.ts |
| function unescapeIdentifier(identifier) { |
| return identifier.startsWith('___') ? identifier.substr(1) : identifier; |
| } |
| function unwrapResolvedMetadata(metadata) { |
| if (metadata && metadata.__symbolic === 'resolved') { |
| return metadata.symbol; |
| } |
| return metadata; |
| } |
| |
| function serializeSummaries(srcFileName, forJitCtx, summaryResolver, symbolResolver, symbols, types, createExternalSymbolReexports) { |
| if (createExternalSymbolReexports === void 0) { createExternalSymbolReexports = false; } |
| var toJsonSerializer = new ToJsonSerializer(symbolResolver, summaryResolver, srcFileName); |
| // for symbols, we use everything except for the class metadata itself |
| // (we keep the statics though), as the class metadata is contained in the |
| // CompileTypeSummary. |
| symbols.forEach(function (resolvedSymbol) { return toJsonSerializer.addSummary({ symbol: resolvedSymbol.symbol, metadata: resolvedSymbol.metadata }); }); |
| // Add type summaries. |
| types.forEach(function (_a) { |
| var summary = _a.summary, metadata = _a.metadata; |
| toJsonSerializer.addSummary({ symbol: summary.type.reference, metadata: undefined, type: summary }); |
| }); |
| var _a = toJsonSerializer.serialize(createExternalSymbolReexports), json = _a.json, exportAs = _a.exportAs; |
| if (forJitCtx) { |
| var forJitSerializer_1 = new ForJitSerializer(forJitCtx, symbolResolver, summaryResolver); |
| types.forEach(function (_a) { |
| var summary = _a.summary, metadata = _a.metadata; |
| forJitSerializer_1.addSourceType(summary, metadata); |
| }); |
| toJsonSerializer.unprocessedSymbolSummariesBySymbol.forEach(function (summary) { |
| if (summaryResolver.isLibraryFile(summary.symbol.filePath) && summary.type) { |
| forJitSerializer_1.addLibType(summary.type); |
| } |
| }); |
| forJitSerializer_1.serialize(exportAs); |
| } |
| return { json: json, exportAs: exportAs }; |
| } |
| function deserializeSummaries(symbolCache, summaryResolver, libraryFileName, json) { |
| var deserializer = new FromJsonDeserializer(symbolCache, summaryResolver); |
| return deserializer.deserialize(libraryFileName, json); |
| } |
| function createForJitStub(outputCtx, reference) { |
| return createSummaryForJitFunction(outputCtx, reference, NULL_EXPR); |
| } |
| function createSummaryForJitFunction(outputCtx, reference, value) { |
| var fnName = summaryForJitName(reference.name); |
| outputCtx.statements.push(fn([], [new ReturnStatement(value)], new ArrayType(DYNAMIC_TYPE)).toDeclStmt(fnName, [ |
| exports.StmtModifier.Final, exports.StmtModifier.Exported |
| ])); |
| } |
| var ToJsonSerializer = /** @class */ (function (_super) { |
| __extends(ToJsonSerializer, _super); |
| function ToJsonSerializer(symbolResolver, summaryResolver, srcFileName) { |
| var _this = _super.call(this) || this; |
| _this.symbolResolver = symbolResolver; |
| _this.summaryResolver = summaryResolver; |
| _this.srcFileName = srcFileName; |
| // Note: This only contains symbols without members. |
| _this.symbols = []; |
| _this.indexBySymbol = new Map(); |
| _this.reexportedBy = new Map(); |
| // This now contains a `__symbol: number` in the place of |
| // StaticSymbols, but otherwise has the same shape as the original objects. |
| _this.processedSummaryBySymbol = new Map(); |
| _this.processedSummaries = []; |
| _this.unprocessedSymbolSummariesBySymbol = new Map(); |
| _this.moduleName = symbolResolver.getKnownModuleName(srcFileName); |
| return _this; |
| } |
| ToJsonSerializer.prototype.addSummary = function (summary) { |
| var _this = this; |
| var unprocessedSummary = this.unprocessedSymbolSummariesBySymbol.get(summary.symbol); |
| var processedSummary = this.processedSummaryBySymbol.get(summary.symbol); |
| if (!unprocessedSummary) { |
| unprocessedSummary = { symbol: summary.symbol, metadata: undefined }; |
| this.unprocessedSymbolSummariesBySymbol.set(summary.symbol, unprocessedSummary); |
| processedSummary = { symbol: this.processValue(summary.symbol, 0 /* None */) }; |
| this.processedSummaries.push(processedSummary); |
| this.processedSummaryBySymbol.set(summary.symbol, processedSummary); |
| } |
| if (!unprocessedSummary.metadata && summary.metadata) { |
| var metadata_1 = summary.metadata || {}; |
| if (metadata_1.__symbolic === 'class') { |
| // For classes, we keep everything except their class decorators. |
| // We need to keep e.g. the ctor args, method names, method decorators |
| // so that the class can be extended in another compilation unit. |
| // We don't keep the class decorators as |
| // 1) they refer to data |
| // that should not cause a rebuild of downstream compilation units |
| // (e.g. inline templates of @Component, or @NgModule.declarations) |
| // 2) their data is already captured in TypeSummaries, e.g. DirectiveSummary. |
| var clone_1 = {}; |
| Object.keys(metadata_1).forEach(function (propName) { |
| if (propName !== 'decorators') { |
| clone_1[propName] = metadata_1[propName]; |
| } |
| }); |
| metadata_1 = clone_1; |
| } |
| else if (isCall(metadata_1)) { |
| if (!isFunctionCall(metadata_1) && !isMethodCallOnVariable(metadata_1)) { |
| // Don't store complex calls as we won't be able to simplify them anyways later on. |
| metadata_1 = { |
| __symbolic: 'error', |
| message: 'Complex function calls are not supported.', |
| }; |
| } |
| } |
| // Note: We need to keep storing ctor calls for e.g. |
| // `export const x = new InjectionToken(...)` |
| unprocessedSummary.metadata = metadata_1; |
| processedSummary.metadata = this.processValue(metadata_1, 1 /* ResolveValue */); |
| if (metadata_1 instanceof StaticSymbol && |
| this.summaryResolver.isLibraryFile(metadata_1.filePath)) { |
| var declarationSymbol = this.symbols[this.indexBySymbol.get(metadata_1)]; |
| if (!isLoweredSymbol(declarationSymbol.name)) { |
| // Note: symbols that were introduced during codegen in the user file can have a reexport |
| // if a user used `export *`. However, we can't rely on this as tsickle will change |
| // `export *` into named exports, using only the information from the typechecker. |
| // As we introduce the new symbols after typecheck, Tsickle does not know about them, |
| // and omits them when expanding `export *`. |
| // So we have to keep reexporting these symbols manually via .ngfactory files. |
| this.reexportedBy.set(declarationSymbol, summary.symbol); |
| } |
| } |
| } |
| if (!unprocessedSummary.type && summary.type) { |
| unprocessedSummary.type = summary.type; |
| // Note: We don't add the summaries of all referenced symbols as for the ResolvedSymbols, |
| // as the type summaries already contain the transitive data that they require |
| // (in a minimal way). |
| processedSummary.type = this.processValue(summary.type, 0 /* None */); |
| // except for reexported directives / pipes, so we need to store |
| // their summaries explicitly. |
| if (summary.type.summaryKind === exports.CompileSummaryKind.NgModule) { |
| var ngModuleSummary = summary.type; |
| ngModuleSummary.exportedDirectives.concat(ngModuleSummary.exportedPipes).forEach(function (id) { |
| var symbol = id.reference; |
| if (_this.summaryResolver.isLibraryFile(symbol.filePath) && |
| !_this.unprocessedSymbolSummariesBySymbol.has(symbol)) { |
| var summary_1 = _this.summaryResolver.resolveSummary(symbol); |
| if (summary_1) { |
| _this.addSummary(summary_1); |
| } |
| } |
| }); |
| } |
| } |
| }; |
| /** |
| * @param createExternalSymbolReexports Whether external static symbols should be re-exported. |
| * This can be enabled if external symbols should be re-exported by the current module in |
| * order to avoid dynamically generated module dependencies which can break strict dependency |
| * enforcements (as in Google3). Read more here: https://github.com/angular/angular/issues/25644 |
| */ |
| ToJsonSerializer.prototype.serialize = function (createExternalSymbolReexports) { |
| var _this = this; |
| var exportAs = []; |
| var json = JSON.stringify({ |
| moduleName: this.moduleName, |
| summaries: this.processedSummaries, |
| symbols: this.symbols.map(function (symbol, index) { |
| symbol.assertNoMembers(); |
| var importAs = undefined; |
| if (_this.summaryResolver.isLibraryFile(symbol.filePath)) { |
| var reexportSymbol = _this.reexportedBy.get(symbol); |
| if (reexportSymbol) { |
| // In case the given external static symbol is already manually exported by the |
| // user, we just proxy the external static symbol reference to the manual export. |
| // This ensures that the AOT compiler imports the external symbol through the |
| // user export and does not introduce another dependency which is not needed. |
| importAs = _this.indexBySymbol.get(reexportSymbol); |
| } |
| else if (createExternalSymbolReexports) { |
| // In this case, the given external static symbol is *not* manually exported by |
| // the user, and we manually create a re-export in the factory file so that we |
| // don't introduce another module dependency. This is useful when running within |
| // Bazel so that the AOT compiler does not introduce any module dependencies |
| // which can break the strict dependency enforcement. (e.g. as in Google3) |
| // Read more about this here: https://github.com/angular/angular/issues/25644 |
| var summary = _this.unprocessedSymbolSummariesBySymbol.get(symbol); |
| if (!summary || !summary.metadata || summary.metadata.__symbolic !== 'interface') { |
| importAs = symbol.name + "_" + index; |
| exportAs.push({ symbol: symbol, exportAs: importAs }); |
| } |
| } |
| } |
| return { |
| __symbol: index, |
| name: symbol.name, |
| filePath: _this.summaryResolver.toSummaryFileName(symbol.filePath, _this.srcFileName), |
| importAs: importAs |
| }; |
| }) |
| }); |
| return { json: json, exportAs: exportAs }; |
| }; |
| ToJsonSerializer.prototype.processValue = function (value, flags) { |
| return visitValue(value, this, flags); |
| }; |
| ToJsonSerializer.prototype.visitOther = function (value, context) { |
| if (value instanceof StaticSymbol) { |
| var baseSymbol = this.symbolResolver.getStaticSymbol(value.filePath, value.name); |
| var index = this.visitStaticSymbol(baseSymbol, context); |
| return { __symbol: index, members: value.members }; |
| } |
| }; |
| /** |
| * Strip line and character numbers from ngsummaries. |
| * Emitting them causes white spaces changes to retrigger upstream |
| * recompilations in bazel. |
| * TODO: find out a way to have line and character numbers in errors without |
| * excessive recompilation in bazel. |
| */ |
| ToJsonSerializer.prototype.visitStringMap = function (map, context) { |
| if (map['__symbolic'] === 'resolved') { |
| return visitValue(map['symbol'], this, context); |
| } |
| if (map['__symbolic'] === 'error') { |
| delete map['line']; |
| delete map['character']; |
| } |
| return _super.prototype.visitStringMap.call(this, map, context); |
| }; |
| /** |
| * Returns null if the options.resolveValue is true, and the summary for the symbol |
| * resolved to a type or could not be resolved. |
| */ |
| ToJsonSerializer.prototype.visitStaticSymbol = function (baseSymbol, flags) { |
| var index = this.indexBySymbol.get(baseSymbol); |
| var summary = null; |
| if (flags & 1 /* ResolveValue */ && |
| this.summaryResolver.isLibraryFile(baseSymbol.filePath)) { |
| if (this.unprocessedSymbolSummariesBySymbol.has(baseSymbol)) { |
| // the summary for this symbol was already added |
| // -> nothing to do. |
| return index; |
| } |
| summary = this.loadSummary(baseSymbol); |
| if (summary && summary.metadata instanceof StaticSymbol) { |
| // The summary is a reexport |
| index = this.visitStaticSymbol(summary.metadata, flags); |
| // reset the summary as it is just a reexport, so we don't want to store it. |
| summary = null; |
| } |
| } |
| else if (index != null) { |
| // Note: == on purpose to compare with undefined! |
| // No summary and the symbol is already added -> nothing to do. |
| return index; |
| } |
| // Note: == on purpose to compare with undefined! |
| if (index == null) { |
| index = this.symbols.length; |
| this.symbols.push(baseSymbol); |
| } |
| this.indexBySymbol.set(baseSymbol, index); |
| if (summary) { |
| this.addSummary(summary); |
| } |
| return index; |
| }; |
| ToJsonSerializer.prototype.loadSummary = function (symbol) { |
| var summary = this.summaryResolver.resolveSummary(symbol); |
| if (!summary) { |
| // some symbols might originate from a plain typescript library |
| // that just exported .d.ts and .metadata.json files, i.e. where no summary |
| // files were created. |
| var resolvedSymbol = this.symbolResolver.resolveSymbol(symbol); |
| if (resolvedSymbol) { |
| summary = { symbol: resolvedSymbol.symbol, metadata: resolvedSymbol.metadata }; |
| } |
| } |
| return summary; |
| }; |
| return ToJsonSerializer; |
| }(ValueTransformer)); |
| var ForJitSerializer = /** @class */ (function () { |
| function ForJitSerializer(outputCtx, symbolResolver, summaryResolver) { |
| this.outputCtx = outputCtx; |
| this.symbolResolver = symbolResolver; |
| this.summaryResolver = summaryResolver; |
| this.data = []; |
| } |
| ForJitSerializer.prototype.addSourceType = function (summary, metadata) { |
| this.data.push({ summary: summary, metadata: metadata, isLibrary: false }); |
| }; |
| ForJitSerializer.prototype.addLibType = function (summary) { |
| this.data.push({ summary: summary, metadata: null, isLibrary: true }); |
| }; |
| ForJitSerializer.prototype.serialize = function (exportAsArr) { |
| var _this = this; |
| var e_1, _a, e_2, _b, e_3, _c; |
| var exportAsBySymbol = new Map(); |
| try { |
| for (var exportAsArr_1 = __values(exportAsArr), exportAsArr_1_1 = exportAsArr_1.next(); !exportAsArr_1_1.done; exportAsArr_1_1 = exportAsArr_1.next()) { |
| var _d = exportAsArr_1_1.value, symbol = _d.symbol, exportAs = _d.exportAs; |
| exportAsBySymbol.set(symbol, exportAs); |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (exportAsArr_1_1 && !exportAsArr_1_1.done && (_a = exportAsArr_1.return)) _a.call(exportAsArr_1); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| var ngModuleSymbols = new Set(); |
| try { |
| for (var _e = __values(this.data), _f = _e.next(); !_f.done; _f = _e.next()) { |
| var _g = _f.value, summary = _g.summary, metadata = _g.metadata, isLibrary = _g.isLibrary; |
| if (summary.summaryKind === exports.CompileSummaryKind.NgModule) { |
| // collect the symbols that refer to NgModule classes. |
| // Note: we can't just rely on `summary.type.summaryKind` to determine this as |
| // we don't add the summaries of all referenced symbols when we serialize type summaries. |
| // See serializeSummaries for details. |
| ngModuleSymbols.add(summary.type.reference); |
| var modSummary = summary; |
| try { |
| for (var _h = __values(modSummary.modules), _j = _h.next(); !_j.done; _j = _h.next()) { |
| var mod = _j.value; |
| ngModuleSymbols.add(mod.reference); |
| } |
| } |
| catch (e_3_1) { e_3 = { error: e_3_1 }; } |
| finally { |
| try { |
| if (_j && !_j.done && (_c = _h.return)) _c.call(_h); |
| } |
| finally { if (e_3) throw e_3.error; } |
| } |
| } |
| if (!isLibrary) { |
| var fnName = summaryForJitName(summary.type.reference.name); |
| createSummaryForJitFunction(this.outputCtx, summary.type.reference, this.serializeSummaryWithDeps(summary, metadata)); |
| } |
| } |
| } |
| catch (e_2_1) { e_2 = { error: e_2_1 }; } |
| finally { |
| try { |
| if (_f && !_f.done && (_b = _e.return)) _b.call(_e); |
| } |
| finally { if (e_2) throw e_2.error; } |
| } |
| ngModuleSymbols.forEach(function (ngModuleSymbol) { |
| if (_this.summaryResolver.isLibraryFile(ngModuleSymbol.filePath)) { |
| var exportAs = exportAsBySymbol.get(ngModuleSymbol) || ngModuleSymbol.name; |
| var jitExportAsName = summaryForJitName(exportAs); |
| _this.outputCtx.statements.push(variable(jitExportAsName) |
| .set(_this.serializeSummaryRef(ngModuleSymbol)) |
| .toDeclStmt(null, [exports.StmtModifier.Exported])); |
| } |
| }); |
| }; |
| ForJitSerializer.prototype.serializeSummaryWithDeps = function (summary, metadata) { |
| var _this = this; |
| var expressions = [this.serializeSummary(summary)]; |
| var providers = []; |
| if (metadata instanceof CompileNgModuleMetadata) { |
| expressions.push.apply(expressions, __spread( |
| // For directives / pipes, we only add the declared ones, |
| // and rely on transitively importing NgModules to get the transitive |
| // summaries. |
| metadata.declaredDirectives.concat(metadata.declaredPipes) |
| .map(function (type) { return type.reference; }) |
| // For modules, |
| // we also add the summaries for modules |
| // from libraries. |
| // This is ok as we produce reexports for all transitive modules. |
| .concat(metadata.transitiveModule.modules.map(function (type) { return type.reference; }) |
| .filter(function (ref) { return ref !== metadata.type.reference; })) |
| .map(function (ref) { return _this.serializeSummaryRef(ref); }))); |
| // Note: We don't use `NgModuleSummary.providers`, as that one is transitive, |
| // and we already have transitive modules. |
| providers = metadata.providers; |
| } |
| else if (summary.summaryKind === exports.CompileSummaryKind.Directive) { |
| var dirSummary = summary; |
| providers = dirSummary.providers.concat(dirSummary.viewProviders); |
| } |
| // Note: We can't just refer to the `ngsummary.ts` files for `useClass` providers (as we do for |
| // declaredDirectives / declaredPipes), as we allow |
| // providers without ctor arguments to skip the `@Injectable` decorator, |
| // i.e. we didn't generate .ngsummary.ts files for these. |
| expressions.push.apply(expressions, __spread(providers.filter(function (provider) { return !!provider.useClass; }).map(function (provider) { return _this.serializeSummary({ |
| summaryKind: exports.CompileSummaryKind.Injectable, type: provider.useClass |
| }); }))); |
| return literalArr(expressions); |
| }; |
| ForJitSerializer.prototype.serializeSummaryRef = function (typeSymbol) { |
| var jitImportedSymbol = this.symbolResolver.getStaticSymbol(summaryForJitFileName(typeSymbol.filePath), summaryForJitName(typeSymbol.name)); |
| return this.outputCtx.importExpr(jitImportedSymbol); |
| }; |
| ForJitSerializer.prototype.serializeSummary = function (data) { |
| var outputCtx = this.outputCtx; |
| var Transformer = /** @class */ (function () { |
| function Transformer() { |
| } |
| Transformer.prototype.visitArray = function (arr, context) { |
| var _this = this; |
| return literalArr(arr.map(function (entry) { return visitValue(entry, _this, context); })); |
| }; |
| Transformer.prototype.visitStringMap = function (map, context) { |
| var _this = this; |
| return new LiteralMapExpr(Object.keys(map).map(function (key) { return new LiteralMapEntry(key, visitValue(map[key], _this, context), false); })); |
| }; |
| Transformer.prototype.visitPrimitive = function (value, context) { return literal(value); }; |
| Transformer.prototype.visitOther = function (value, context) { |
| if (value instanceof StaticSymbol) { |
| return outputCtx.importExpr(value); |
| } |
| else { |
| throw new Error("Illegal State: Encountered value " + value); |
| } |
| }; |
| return Transformer; |
| }()); |
| return visitValue(data, new Transformer(), null); |
| }; |
| return ForJitSerializer; |
| }()); |
| var FromJsonDeserializer = /** @class */ (function (_super) { |
| __extends(FromJsonDeserializer, _super); |
| function FromJsonDeserializer(symbolCache, summaryResolver) { |
| var _this = _super.call(this) || this; |
| _this.symbolCache = symbolCache; |
| _this.summaryResolver = summaryResolver; |
| return _this; |
| } |
| FromJsonDeserializer.prototype.deserialize = function (libraryFileName, json) { |
| var _this = this; |
| var data = JSON.parse(json); |
| var allImportAs = []; |
| this.symbols = data.symbols.map(function (serializedSymbol) { return _this.symbolCache.get(_this.summaryResolver.fromSummaryFileName(serializedSymbol.filePath, libraryFileName), serializedSymbol.name); }); |
| data.symbols.forEach(function (serializedSymbol, index) { |
| var symbol = _this.symbols[index]; |
| var importAs = serializedSymbol.importAs; |
| if (typeof importAs === 'number') { |
| allImportAs.push({ symbol: symbol, importAs: _this.symbols[importAs] }); |
| } |
| else if (typeof importAs === 'string') { |
| allImportAs.push({ symbol: symbol, importAs: _this.symbolCache.get(ngfactoryFilePath(libraryFileName), importAs) }); |
| } |
| }); |
| var summaries = visitValue(data.summaries, this, null); |
| return { moduleName: data.moduleName, summaries: summaries, importAs: allImportAs }; |
| }; |
| FromJsonDeserializer.prototype.visitStringMap = function (map, context) { |
| if ('__symbol' in map) { |
| var baseSymbol = this.symbols[map['__symbol']]; |
| var members = map['members']; |
| return members.length ? this.symbolCache.get(baseSymbol.filePath, baseSymbol.name, members) : |
| baseSymbol; |
| } |
| else { |
| return _super.prototype.visitStringMap.call(this, map, context); |
| } |
| }; |
| return FromJsonDeserializer; |
| }(ValueTransformer)); |
| function isCall(metadata) { |
| return metadata && metadata.__symbolic === 'call'; |
| } |
| function isFunctionCall(metadata) { |
| return isCall(metadata) && unwrapResolvedMetadata(metadata.expression) instanceof StaticSymbol; |
| } |
| function isMethodCallOnVariable(metadata) { |
| return isCall(metadata) && metadata.expression && metadata.expression.__symbolic === 'select' && |
| unwrapResolvedMetadata(metadata.expression.expression) instanceof StaticSymbol; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var AotCompiler = /** @class */ (function () { |
| function AotCompiler(_config, _options, _host, reflector, _metadataResolver, _templateParser, _styleCompiler, _viewCompiler, _typeCheckCompiler, _ngModuleCompiler, _injectableCompiler, _outputEmitter, _summaryResolver, _symbolResolver) { |
| this._config = _config; |
| this._options = _options; |
| this._host = _host; |
| this.reflector = reflector; |
| this._metadataResolver = _metadataResolver; |
| this._templateParser = _templateParser; |
| this._styleCompiler = _styleCompiler; |
| this._viewCompiler = _viewCompiler; |
| this._typeCheckCompiler = _typeCheckCompiler; |
| this._ngModuleCompiler = _ngModuleCompiler; |
| this._injectableCompiler = _injectableCompiler; |
| this._outputEmitter = _outputEmitter; |
| this._summaryResolver = _summaryResolver; |
| this._symbolResolver = _symbolResolver; |
| this._templateAstCache = new Map(); |
| this._analyzedFiles = new Map(); |
| this._analyzedFilesForInjectables = new Map(); |
| } |
| AotCompiler.prototype.clearCache = function () { this._metadataResolver.clearCache(); }; |
| AotCompiler.prototype.analyzeModulesSync = function (rootFiles) { |
| var _this = this; |
| var analyzeResult = analyzeAndValidateNgModules(rootFiles, this._host, this._symbolResolver, this._metadataResolver); |
| analyzeResult.ngModules.forEach(function (ngModule) { return _this._metadataResolver.loadNgModuleDirectiveAndPipeMetadata(ngModule.type.reference, true); }); |
| return analyzeResult; |
| }; |
| AotCompiler.prototype.analyzeModulesAsync = function (rootFiles) { |
| var _this = this; |
| var analyzeResult = analyzeAndValidateNgModules(rootFiles, this._host, this._symbolResolver, this._metadataResolver); |
| return Promise |
| .all(analyzeResult.ngModules.map(function (ngModule) { return _this._metadataResolver.loadNgModuleDirectiveAndPipeMetadata(ngModule.type.reference, false); })) |
| .then(function () { return analyzeResult; }); |
| }; |
| AotCompiler.prototype._analyzeFile = function (fileName) { |
| var analyzedFile = this._analyzedFiles.get(fileName); |
| if (!analyzedFile) { |
| analyzedFile = |
| analyzeFile(this._host, this._symbolResolver, this._metadataResolver, fileName); |
| this._analyzedFiles.set(fileName, analyzedFile); |
| } |
| return analyzedFile; |
| }; |
| AotCompiler.prototype._analyzeFileForInjectables = function (fileName) { |
| var analyzedFile = this._analyzedFilesForInjectables.get(fileName); |
| if (!analyzedFile) { |
| analyzedFile = analyzeFileForInjectables(this._host, this._symbolResolver, this._metadataResolver, fileName); |
| this._analyzedFilesForInjectables.set(fileName, analyzedFile); |
| } |
| return analyzedFile; |
| }; |
| AotCompiler.prototype.findGeneratedFileNames = function (fileName) { |
| var _this = this; |
| var genFileNames = []; |
| var file = this._analyzeFile(fileName); |
| // Make sure we create a .ngfactory if we have a injectable/directive/pipe/NgModule |
| // or a reference to a non source file. |
| // Note: This is overestimating the required .ngfactory files as the real calculation is harder. |
| // Only do this for StubEmitFlags.Basic, as adding a type check block |
| // does not change this file (as we generate type check blocks based on NgModules). |
| if (this._options.allowEmptyCodegenFiles || file.directives.length || file.pipes.length || |
| file.injectables.length || file.ngModules.length || file.exportsNonSourceFiles) { |
| genFileNames.push(ngfactoryFilePath(file.fileName, true)); |
| if (this._options.enableSummariesForJit) { |
| genFileNames.push(summaryForJitFileName(file.fileName, true)); |
| } |
| } |
| var fileSuffix = normalizeGenFileSuffix(splitTypescriptSuffix(file.fileName, true)[1]); |
| file.directives.forEach(function (dirSymbol) { |
| var compMeta = _this._metadataResolver.getNonNormalizedDirectiveMetadata(dirSymbol).metadata; |
| if (!compMeta.isComponent) { |
| return; |
| } |
| // Note: compMeta is a component and therefore template is non null. |
| compMeta.template.styleUrls.forEach(function (styleUrl) { |
| var normalizedUrl = _this._host.resourceNameToFileName(styleUrl, file.fileName); |
| if (!normalizedUrl) { |
| throw syntaxError("Couldn't resolve resource " + styleUrl + " relative to " + file.fileName); |
| } |
| var needsShim = (compMeta.template.encapsulation || |
| _this._config.defaultEncapsulation) === ViewEncapsulation.Emulated; |
| genFileNames.push(_stylesModuleUrl(normalizedUrl, needsShim, fileSuffix)); |
| if (_this._options.allowEmptyCodegenFiles) { |
| genFileNames.push(_stylesModuleUrl(normalizedUrl, !needsShim, fileSuffix)); |
| } |
| }); |
| }); |
| return genFileNames; |
| }; |
| AotCompiler.prototype.emitBasicStub = function (genFileName, originalFileName) { |
| var outputCtx = this._createOutputContext(genFileName); |
| if (genFileName.endsWith('.ngfactory.ts')) { |
| if (!originalFileName) { |
| throw new Error("Assertion error: require the original file for .ngfactory.ts stubs. File: " + genFileName); |
| } |
| var originalFile = this._analyzeFile(originalFileName); |
| this._createNgFactoryStub(outputCtx, originalFile, 1 /* Basic */); |
| } |
| else if (genFileName.endsWith('.ngsummary.ts')) { |
| if (this._options.enableSummariesForJit) { |
| if (!originalFileName) { |
| throw new Error("Assertion error: require the original file for .ngsummary.ts stubs. File: " + genFileName); |
| } |
| var originalFile = this._analyzeFile(originalFileName); |
| _createEmptyStub(outputCtx); |
| originalFile.ngModules.forEach(function (ngModule) { |
| // create exports that user code can reference |
| createForJitStub(outputCtx, ngModule.type.reference); |
| }); |
| } |
| } |
| else if (genFileName.endsWith('.ngstyle.ts')) { |
| _createEmptyStub(outputCtx); |
| } |
| // Note: for the stubs, we don't need a property srcFileUrl, |
| // as later on in emitAllImpls we will create the proper GeneratedFiles with the |
| // correct srcFileUrl. |
| // This is good as e.g. for .ngstyle.ts files we can't derive |
| // the url of components based on the genFileUrl. |
| return this._codegenSourceModule('unknown', outputCtx); |
| }; |
| AotCompiler.prototype.emitTypeCheckStub = function (genFileName, originalFileName) { |
| var originalFile = this._analyzeFile(originalFileName); |
| var outputCtx = this._createOutputContext(genFileName); |
| if (genFileName.endsWith('.ngfactory.ts')) { |
| this._createNgFactoryStub(outputCtx, originalFile, 2 /* TypeCheck */); |
| } |
| return outputCtx.statements.length > 0 ? |
| this._codegenSourceModule(originalFile.fileName, outputCtx) : |
| null; |
| }; |
| AotCompiler.prototype.loadFilesAsync = function (fileNames, tsFiles) { |
| var _this = this; |
| var files = fileNames.map(function (fileName) { return _this._analyzeFile(fileName); }); |
| var loadingPromises = []; |
| files.forEach(function (file) { return file.ngModules.forEach(function (ngModule) { |
| return loadingPromises.push(_this._metadataResolver.loadNgModuleDirectiveAndPipeMetadata(ngModule.type.reference, false)); |
| }); }); |
| var analyzedInjectables = tsFiles.map(function (tsFile) { return _this._analyzeFileForInjectables(tsFile); }); |
| return Promise.all(loadingPromises).then(function (_) { return ({ |
| analyzedModules: mergeAndValidateNgFiles(files), |
| analyzedInjectables: analyzedInjectables, |
| }); }); |
| }; |
| AotCompiler.prototype.loadFilesSync = function (fileNames, tsFiles) { |
| var _this = this; |
| var files = fileNames.map(function (fileName) { return _this._analyzeFile(fileName); }); |
| files.forEach(function (file) { return file.ngModules.forEach(function (ngModule) { return _this._metadataResolver.loadNgModuleDirectiveAndPipeMetadata(ngModule.type.reference, true); }); }); |
| var analyzedInjectables = tsFiles.map(function (tsFile) { return _this._analyzeFileForInjectables(tsFile); }); |
| return { |
| analyzedModules: mergeAndValidateNgFiles(files), |
| analyzedInjectables: analyzedInjectables, |
| }; |
| }; |
| AotCompiler.prototype._createNgFactoryStub = function (outputCtx, file, emitFlags) { |
| var _this = this; |
| var componentId = 0; |
| file.ngModules.forEach(function (ngModuleMeta, ngModuleIndex) { |
| // Note: the code below needs to executed for StubEmitFlags.Basic and StubEmitFlags.TypeCheck, |
| // so we don't change the .ngfactory file too much when adding the type-check block. |
| // create exports that user code can reference |
| _this._ngModuleCompiler.createStub(outputCtx, ngModuleMeta.type.reference); |
| // add references to the symbols from the metadata. |
| // These can be used by the type check block for components, |
| // and they also cause TypeScript to include these files into the program too, |
| // which will make them part of the analyzedFiles. |
| var externalReferences = __spread(ngModuleMeta.transitiveModule.directives.map(function (d) { return d.reference; }), ngModuleMeta.transitiveModule.pipes.map(function (d) { return d.reference; }), ngModuleMeta.importedModules.map(function (m) { return m.type.reference; }), ngModuleMeta.exportedModules.map(function (m) { return m.type.reference; }), _this._externalIdentifierReferences([Identifiers.TemplateRef, Identifiers.ElementRef])); |
| var externalReferenceVars = new Map(); |
| externalReferences.forEach(function (ref, typeIndex) { |
| externalReferenceVars.set(ref, "_decl" + ngModuleIndex + "_" + typeIndex); |
| }); |
| externalReferenceVars.forEach(function (varName, reference) { |
| outputCtx.statements.push(variable(varName) |
| .set(NULL_EXPR.cast(DYNAMIC_TYPE)) |
| .toDeclStmt(expressionType(outputCtx.importExpr(reference, /* typeParams */ null, /* useSummaries */ false)))); |
| }); |
| if (emitFlags & 2 /* TypeCheck */) { |
| // add the type-check block for all components of the NgModule |
| ngModuleMeta.declaredDirectives.forEach(function (dirId) { |
| var compMeta = _this._metadataResolver.getDirectiveMetadata(dirId.reference); |
| if (!compMeta.isComponent) { |
| return; |
| } |
| componentId++; |
| _this._createTypeCheckBlock(outputCtx, compMeta.type.reference.name + "_Host_" + componentId, ngModuleMeta, _this._metadataResolver.getHostComponentMetadata(compMeta), [compMeta.type], externalReferenceVars); |
| _this._createTypeCheckBlock(outputCtx, compMeta.type.reference.name + "_" + componentId, ngModuleMeta, compMeta, ngModuleMeta.transitiveModule.directives, externalReferenceVars); |
| }); |
| } |
| }); |
| if (outputCtx.statements.length === 0) { |
| _createEmptyStub(outputCtx); |
| } |
| }; |
| AotCompiler.prototype._externalIdentifierReferences = function (references) { |
| var e_1, _a; |
| var result = []; |
| try { |
| for (var references_1 = __values(references), references_1_1 = references_1.next(); !references_1_1.done; references_1_1 = references_1.next()) { |
| var reference = references_1_1.value; |
| var token = createTokenForExternalReference(this.reflector, reference); |
| if (token.identifier) { |
| result.push(token.identifier.reference); |
| } |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (references_1_1 && !references_1_1.done && (_a = references_1.return)) _a.call(references_1); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| return result; |
| }; |
| AotCompiler.prototype._createTypeCheckBlock = function (ctx, componentId, moduleMeta, compMeta, directives, externalReferenceVars) { |
| var _a; |
| var _b = this._parseTemplate(compMeta, moduleMeta, directives), parsedTemplate = _b.template, usedPipes = _b.pipes; |
| (_a = ctx.statements).push.apply(_a, __spread(this._typeCheckCompiler.compileComponent(componentId, compMeta, parsedTemplate, usedPipes, externalReferenceVars, ctx))); |
| }; |
| AotCompiler.prototype.emitMessageBundle = function (analyzeResult, locale) { |
| var _this = this; |
| var errors = []; |
| var htmlParser = new HtmlParser(); |
| // TODO(vicb): implicit tags & attributes |
| var messageBundle = new MessageBundle(htmlParser, [], {}, locale); |
| analyzeResult.files.forEach(function (file) { |
| var compMetas = []; |
| file.directives.forEach(function (directiveType) { |
| var dirMeta = _this._metadataResolver.getDirectiveMetadata(directiveType); |
| if (dirMeta && dirMeta.isComponent) { |
| compMetas.push(dirMeta); |
| } |
| }); |
| compMetas.forEach(function (compMeta) { |
| var html = compMeta.template.template; |
| // Template URL points to either an HTML or TS file depending on whether |
| // the file is used with `templateUrl:` or `template:`, respectively. |
| var templateUrl = compMeta.template.templateUrl; |
| var interpolationConfig = InterpolationConfig.fromArray(compMeta.template.interpolation); |
| errors.push.apply(errors, __spread(messageBundle.updateFromTemplate(html, templateUrl, interpolationConfig))); |
| }); |
| }); |
| if (errors.length) { |
| throw new Error(errors.map(function (e) { return e.toString(); }).join('\n')); |
| } |
| return messageBundle; |
| }; |
| AotCompiler.prototype.emitAllPartialModules = function (_a, r3Files) { |
| var _this = this; |
| var ngModuleByPipeOrDirective = _a.ngModuleByPipeOrDirective, files = _a.files; |
| var contextMap = new Map(); |
| var getContext = function (fileName) { |
| if (!contextMap.has(fileName)) { |
| contextMap.set(fileName, _this._createOutputContext(fileName)); |
| } |
| return contextMap.get(fileName); |
| }; |
| files.forEach(function (file) { return _this._compilePartialModule(file.fileName, ngModuleByPipeOrDirective, file.directives, file.pipes, file.ngModules, file.injectables, getContext(file.fileName)); }); |
| r3Files.forEach(function (file) { return _this._compileShallowModules(file.fileName, file.shallowModules, getContext(file.fileName)); }); |
| return Array.from(contextMap.values()) |
| .map(function (context) { return ({ |
| fileName: context.genFilePath, |
| statements: __spread(context.constantPool.statements, context.statements), |
| }); }); |
| }; |
| AotCompiler.prototype._compileShallowModules = function (fileName, shallowModules, context) { |
| var _this = this; |
| shallowModules.forEach(function (module) { return compileNgModuleFromRender2(context, module, _this._injectableCompiler); }); |
| }; |
| AotCompiler.prototype._compilePartialModule = function (fileName, ngModuleByPipeOrDirective, directives, pipes, ngModules, injectables, context) { |
| var _this = this; |
| var errors = []; |
| var schemaRegistry = new DomElementSchemaRegistry(); |
| var hostBindingParser = new BindingParser(this._templateParser.expressionParser, DEFAULT_INTERPOLATION_CONFIG, schemaRegistry, [], errors); |
| // Process all components and directives |
| directives.forEach(function (directiveType) { |
| var directiveMetadata = _this._metadataResolver.getDirectiveMetadata(directiveType); |
| if (directiveMetadata.isComponent) { |
| var module = ngModuleByPipeOrDirective.get(directiveType); |
| module || |
| error("Cannot determine the module for component '" + identifierName(directiveMetadata.type) + "'"); |
| var htmlAst = directiveMetadata.template.htmlAst; |
| var preserveWhitespaces = directiveMetadata.template.preserveWhitespaces; |
| if (!preserveWhitespaces) { |
| htmlAst = removeWhitespaces(htmlAst); |
| } |
| var render3Ast = htmlAstToRender3Ast(htmlAst.rootNodes, hostBindingParser); |
| // Map of StaticType by directive selectors |
| var directiveTypeBySel_1 = new Map(); |
| var directives_1 = module.transitiveModule.directives.map(function (dir) { return _this._metadataResolver.getDirectiveSummary(dir.reference); }); |
| directives_1.forEach(function (directive) { |
| if (directive.selector) { |
| directiveTypeBySel_1.set(directive.selector, directive.type.reference); |
| } |
| }); |
| // Map of StaticType by pipe names |
| var pipeTypeByName_1 = new Map(); |
| var pipes_1 = module.transitiveModule.pipes.map(function (pipe) { return _this._metadataResolver.getPipeSummary(pipe.reference); }); |
| pipes_1.forEach(function (pipe) { pipeTypeByName_1.set(pipe.name, pipe.type.reference); }); |
| compileComponentFromRender2(context, directiveMetadata, render3Ast, _this.reflector, hostBindingParser, directiveTypeBySel_1, pipeTypeByName_1); |
| } |
| else { |
| compileDirectiveFromRender2(context, directiveMetadata, _this.reflector, hostBindingParser); |
| } |
| }); |
| pipes.forEach(function (pipeType) { |
| var pipeMetadata = _this._metadataResolver.getPipeMetadata(pipeType); |
| if (pipeMetadata) { |
| compilePipeFromRender2(context, pipeMetadata, _this.reflector); |
| } |
| }); |
| injectables.forEach(function (injectable) { return _this._injectableCompiler.compile(injectable, context); }); |
| }; |
| AotCompiler.prototype.emitAllPartialModules2 = function (files) { |
| var _this = this; |
| // Using reduce like this is a select many pattern (where map is a select pattern) |
| return files.reduce(function (r, file) { |
| r.push.apply(r, __spread(_this._emitPartialModule2(file.fileName, file.injectables))); |
| return r; |
| }, []); |
| }; |
| AotCompiler.prototype._emitPartialModule2 = function (fileName, injectables) { |
| var _this = this; |
| var context = this._createOutputContext(fileName); |
| injectables.forEach(function (injectable) { return _this._injectableCompiler.compile(injectable, context); }); |
| if (context.statements && context.statements.length > 0) { |
| return [{ fileName: fileName, statements: __spread(context.constantPool.statements, context.statements) }]; |
| } |
| return []; |
| }; |
| AotCompiler.prototype.emitAllImpls = function (analyzeResult) { |
| var _this = this; |
| var ngModuleByPipeOrDirective = analyzeResult.ngModuleByPipeOrDirective, files = analyzeResult.files; |
| var sourceModules = files.map(function (file) { return _this._compileImplFile(file.fileName, ngModuleByPipeOrDirective, file.directives, file.pipes, file.ngModules, file.injectables); }); |
| return flatten(sourceModules); |
| }; |
| AotCompiler.prototype._compileImplFile = function (srcFileUrl, ngModuleByPipeOrDirective, directives, pipes, ngModules, injectables) { |
| var _this = this; |
| var fileSuffix = normalizeGenFileSuffix(splitTypescriptSuffix(srcFileUrl, true)[1]); |
| var generatedFiles = []; |
| var outputCtx = this._createOutputContext(ngfactoryFilePath(srcFileUrl, true)); |
| generatedFiles.push.apply(generatedFiles, __spread(this._createSummary(srcFileUrl, directives, pipes, ngModules, injectables, outputCtx))); |
| // compile all ng modules |
| ngModules.forEach(function (ngModuleMeta) { return _this._compileModule(outputCtx, ngModuleMeta); }); |
| // compile components |
| directives.forEach(function (dirType) { |
| var compMeta = _this._metadataResolver.getDirectiveMetadata(dirType); |
| if (!compMeta.isComponent) { |
| return; |
| } |
| var ngModule = ngModuleByPipeOrDirective.get(dirType); |
| if (!ngModule) { |
| throw new Error("Internal Error: cannot determine the module for component " + identifierName(compMeta.type) + "!"); |
| } |
| // compile styles |
| var componentStylesheet = _this._styleCompiler.compileComponent(outputCtx, compMeta); |
| // Note: compMeta is a component and therefore template is non null. |
| compMeta.template.externalStylesheets.forEach(function (stylesheetMeta) { |
| // Note: fill non shim and shim style files as they might |
| // be shared by component with and without ViewEncapsulation. |
| var shim = _this._styleCompiler.needsStyleShim(compMeta); |
| generatedFiles.push(_this._codegenStyles(srcFileUrl, compMeta, stylesheetMeta, shim, fileSuffix)); |
| if (_this._options.allowEmptyCodegenFiles) { |
| generatedFiles.push(_this._codegenStyles(srcFileUrl, compMeta, stylesheetMeta, !shim, fileSuffix)); |
| } |
| }); |
| // compile components |
| var compViewVars = _this._compileComponent(outputCtx, compMeta, ngModule, ngModule.transitiveModule.directives, componentStylesheet, fileSuffix); |
| _this._compileComponentFactory(outputCtx, compMeta, ngModule, fileSuffix); |
| }); |
| if (outputCtx.statements.length > 0 || this._options.allowEmptyCodegenFiles) { |
| var srcModule = this._codegenSourceModule(srcFileUrl, outputCtx); |
| generatedFiles.unshift(srcModule); |
| } |
| return generatedFiles; |
| }; |
| AotCompiler.prototype._createSummary = function (srcFileName, directives, pipes, ngModules, injectables, ngFactoryCtx) { |
| var _this = this; |
| var symbolSummaries = this._symbolResolver.getSymbolsOf(srcFileName) |
| .map(function (symbol) { return _this._symbolResolver.resolveSymbol(symbol); }); |
| var typeData = __spread(ngModules.map(function (meta) { return ({ |
| summary: _this._metadataResolver.getNgModuleSummary(meta.type.reference), |
| metadata: _this._metadataResolver.getNgModuleMetadata(meta.type.reference) |
| }); }), directives.map(function (ref) { return ({ |
| summary: _this._metadataResolver.getDirectiveSummary(ref), |
| metadata: _this._metadataResolver.getDirectiveMetadata(ref) |
| }); }), pipes.map(function (ref) { return ({ |
| summary: _this._metadataResolver.getPipeSummary(ref), |
| metadata: _this._metadataResolver.getPipeMetadata(ref) |
| }); }), injectables.map(function (ref) { return ({ |
| summary: _this._metadataResolver.getInjectableSummary(ref.symbol), |
| metadata: _this._metadataResolver.getInjectableSummary(ref.symbol).type |
| }); })); |
| var forJitOutputCtx = this._options.enableSummariesForJit ? |
| this._createOutputContext(summaryForJitFileName(srcFileName, true)) : |
| null; |
| var _a = serializeSummaries(srcFileName, forJitOutputCtx, this._summaryResolver, this._symbolResolver, symbolSummaries, typeData, this._options.createExternalSymbolFactoryReexports), json = _a.json, exportAs = _a.exportAs; |
| exportAs.forEach(function (entry) { |
| ngFactoryCtx.statements.push(variable(entry.exportAs).set(ngFactoryCtx.importExpr(entry.symbol)).toDeclStmt(null, [ |
| exports.StmtModifier.Exported |
| ])); |
| }); |
| var summaryJson = new GeneratedFile(srcFileName, summaryFileName(srcFileName), json); |
| var result = [summaryJson]; |
| if (forJitOutputCtx) { |
| result.push(this._codegenSourceModule(srcFileName, forJitOutputCtx)); |
| } |
| return result; |
| }; |
| AotCompiler.prototype._compileModule = function (outputCtx, ngModule) { |
| var providers = []; |
| if (this._options.locale) { |
| var normalizedLocale = this._options.locale.replace(/_/g, '-'); |
| providers.push({ |
| token: createTokenForExternalReference(this.reflector, Identifiers.LOCALE_ID), |
| useValue: normalizedLocale, |
| }); |
| } |
| if (this._options.i18nFormat) { |
| providers.push({ |
| token: createTokenForExternalReference(this.reflector, Identifiers.TRANSLATIONS_FORMAT), |
| useValue: this._options.i18nFormat |
| }); |
| } |
| this._ngModuleCompiler.compile(outputCtx, ngModule, providers); |
| }; |
| AotCompiler.prototype._compileComponentFactory = function (outputCtx, compMeta, ngModule, fileSuffix) { |
| var hostMeta = this._metadataResolver.getHostComponentMetadata(compMeta); |
| var hostViewFactoryVar = this._compileComponent(outputCtx, hostMeta, ngModule, [compMeta.type], null, fileSuffix) |
| .viewClassVar; |
| var compFactoryVar = componentFactoryName(compMeta.type.reference); |
| var inputsExprs = []; |
| for (var propName in compMeta.inputs) { |
| var templateName = compMeta.inputs[propName]; |
| // Don't quote so that the key gets minified... |
| inputsExprs.push(new LiteralMapEntry(propName, literal(templateName), false)); |
| } |
| var outputsExprs = []; |
| for (var propName in compMeta.outputs) { |
| var templateName = compMeta.outputs[propName]; |
| // Don't quote so that the key gets minified... |
| outputsExprs.push(new LiteralMapEntry(propName, literal(templateName), false)); |
| } |
| outputCtx.statements.push(variable(compFactoryVar) |
| .set(importExpr(Identifiers.createComponentFactory).callFn([ |
| literal(compMeta.selector), outputCtx.importExpr(compMeta.type.reference), |
| variable(hostViewFactoryVar), new LiteralMapExpr(inputsExprs), |
| new LiteralMapExpr(outputsExprs), |
| literalArr(compMeta.template.ngContentSelectors.map(function (selector) { return literal(selector); })) |
| ])) |
| .toDeclStmt(importType(Identifiers.ComponentFactory, [expressionType(outputCtx.importExpr(compMeta.type.reference))], [TypeModifier.Const]), [exports.StmtModifier.Final, exports.StmtModifier.Exported])); |
| }; |
| AotCompiler.prototype._compileComponent = function (outputCtx, compMeta, ngModule, directiveIdentifiers, componentStyles, fileSuffix) { |
| var _a = this._parseTemplate(compMeta, ngModule, directiveIdentifiers), parsedTemplate = _a.template, usedPipes = _a.pipes; |
| var stylesExpr = componentStyles ? variable(componentStyles.stylesVar) : literalArr([]); |
| var viewResult = this._viewCompiler.compileComponent(outputCtx, compMeta, parsedTemplate, stylesExpr, usedPipes); |
| if (componentStyles) { |
| _resolveStyleStatements(this._symbolResolver, componentStyles, this._styleCompiler.needsStyleShim(compMeta), fileSuffix); |
| } |
| return viewResult; |
| }; |
| AotCompiler.prototype._parseTemplate = function (compMeta, ngModule, directiveIdentifiers) { |
| var _this = this; |
| if (this._templateAstCache.has(compMeta.type.reference)) { |
| return this._templateAstCache.get(compMeta.type.reference); |
| } |
| var preserveWhitespaces = compMeta.template.preserveWhitespaces; |
| var directives = directiveIdentifiers.map(function (dir) { return _this._metadataResolver.getDirectiveSummary(dir.reference); }); |
| var pipes = ngModule.transitiveModule.pipes.map(function (pipe) { return _this._metadataResolver.getPipeSummary(pipe.reference); }); |
| var result = this._templateParser.parse(compMeta, compMeta.template.htmlAst, directives, pipes, ngModule.schemas, templateSourceUrl(ngModule.type, compMeta, compMeta.template), preserveWhitespaces); |
| this._templateAstCache.set(compMeta.type.reference, result); |
| return result; |
| }; |
| AotCompiler.prototype._createOutputContext = function (genFilePath) { |
| var _this = this; |
| var importExpr$1 = function (symbol, typeParams, useSummaries) { |
| if (typeParams === void 0) { typeParams = null; } |
| if (useSummaries === void 0) { useSummaries = true; } |
| if (!(symbol instanceof StaticSymbol)) { |
| throw new Error("Internal error: unknown identifier " + JSON.stringify(symbol)); |
| } |
| var arity = _this._symbolResolver.getTypeArity(symbol) || 0; |
| var _a = _this._symbolResolver.getImportAs(symbol, useSummaries) || symbol, filePath = _a.filePath, name = _a.name, members = _a.members; |
| var importModule = _this._fileNameToModuleName(filePath, genFilePath); |
| // It should be good enough to compare filePath to genFilePath and if they are equal |
| // there is a self reference. However, ngfactory files generate to .ts but their |
| // symbols have .d.ts so a simple compare is insufficient. They should be canonical |
| // and is tracked by #17705. |
| var selfReference = _this._fileNameToModuleName(genFilePath, genFilePath); |
| var moduleName = importModule === selfReference ? null : importModule; |
| // If we are in a type expression that refers to a generic type then supply |
| // the required type parameters. If there were not enough type parameters |
| // supplied, supply any as the type. Outside a type expression the reference |
| // should not supply type parameters and be treated as a simple value reference |
| // to the constructor function itself. |
| var suppliedTypeParams = typeParams || []; |
| var missingTypeParamsCount = arity - suppliedTypeParams.length; |
| var allTypeParams = suppliedTypeParams.concat(new Array(missingTypeParamsCount).fill(DYNAMIC_TYPE)); |
| return members.reduce(function (expr, memberName) { return expr.prop(memberName); }, importExpr(new ExternalReference(moduleName, name, null), allTypeParams)); |
| }; |
| return { statements: [], genFilePath: genFilePath, importExpr: importExpr$1, constantPool: new ConstantPool() }; |
| }; |
| AotCompiler.prototype._fileNameToModuleName = function (importedFilePath, containingFilePath) { |
| return this._summaryResolver.getKnownModuleName(importedFilePath) || |
| this._symbolResolver.getKnownModuleName(importedFilePath) || |
| this._host.fileNameToModuleName(importedFilePath, containingFilePath); |
| }; |
| AotCompiler.prototype._codegenStyles = function (srcFileUrl, compMeta, stylesheetMetadata, isShimmed, fileSuffix) { |
| var outputCtx = this._createOutputContext(_stylesModuleUrl(stylesheetMetadata.moduleUrl, isShimmed, fileSuffix)); |
| var compiledStylesheet = this._styleCompiler.compileStyles(outputCtx, compMeta, stylesheetMetadata, isShimmed); |
| _resolveStyleStatements(this._symbolResolver, compiledStylesheet, isShimmed, fileSuffix); |
| return this._codegenSourceModule(srcFileUrl, outputCtx); |
| }; |
| AotCompiler.prototype._codegenSourceModule = function (srcFileUrl, ctx) { |
| return new GeneratedFile(srcFileUrl, ctx.genFilePath, ctx.statements); |
| }; |
| AotCompiler.prototype.listLazyRoutes = function (entryRoute, analyzedModules) { |
| var e_2, _a, e_3, _b; |
| var self = this; |
| if (entryRoute) { |
| var symbol = parseLazyRoute(entryRoute, this.reflector).referencedModule; |
| return visitLazyRoute(symbol); |
| } |
| else if (analyzedModules) { |
| var allLazyRoutes = []; |
| try { |
| for (var _c = __values(analyzedModules.ngModules), _d = _c.next(); !_d.done; _d = _c.next()) { |
| var ngModule = _d.value; |
| var lazyRoutes = listLazyRoutes(ngModule, this.reflector); |
| try { |
| for (var lazyRoutes_1 = __values(lazyRoutes), lazyRoutes_1_1 = lazyRoutes_1.next(); !lazyRoutes_1_1.done; lazyRoutes_1_1 = lazyRoutes_1.next()) { |
| var lazyRoute = lazyRoutes_1_1.value; |
| allLazyRoutes.push(lazyRoute); |
| } |
| } |
| catch (e_3_1) { e_3 = { error: e_3_1 }; } |
| finally { |
| try { |
| if (lazyRoutes_1_1 && !lazyRoutes_1_1.done && (_b = lazyRoutes_1.return)) _b.call(lazyRoutes_1); |
| } |
| finally { if (e_3) throw e_3.error; } |
| } |
| } |
| } |
| catch (e_2_1) { e_2 = { error: e_2_1 }; } |
| finally { |
| try { |
| if (_d && !_d.done && (_a = _c.return)) _a.call(_c); |
| } |
| finally { if (e_2) throw e_2.error; } |
| } |
| return allLazyRoutes; |
| } |
| else { |
| throw new Error("Either route or analyzedModules has to be specified!"); |
| } |
| function visitLazyRoute(symbol, seenRoutes, allLazyRoutes) { |
| var e_4, _a; |
| if (seenRoutes === void 0) { seenRoutes = new Set(); } |
| if (allLazyRoutes === void 0) { allLazyRoutes = []; } |
| // Support pointing to default exports, but stop recursing there, |
| // as the StaticReflector does not yet support default exports. |
| if (seenRoutes.has(symbol) || !symbol.name) { |
| return allLazyRoutes; |
| } |
| seenRoutes.add(symbol); |
| var lazyRoutes = listLazyRoutes(self._metadataResolver.getNgModuleMetadata(symbol, true), self.reflector); |
| try { |
| for (var lazyRoutes_2 = __values(lazyRoutes), lazyRoutes_2_1 = lazyRoutes_2.next(); !lazyRoutes_2_1.done; lazyRoutes_2_1 = lazyRoutes_2.next()) { |
| var lazyRoute = lazyRoutes_2_1.value; |
| allLazyRoutes.push(lazyRoute); |
| visitLazyRoute(lazyRoute.referencedModule, seenRoutes, allLazyRoutes); |
| } |
| } |
| catch (e_4_1) { e_4 = { error: e_4_1 }; } |
| finally { |
| try { |
| if (lazyRoutes_2_1 && !lazyRoutes_2_1.done && (_a = lazyRoutes_2.return)) _a.call(lazyRoutes_2); |
| } |
| finally { if (e_4) throw e_4.error; } |
| } |
| return allLazyRoutes; |
| } |
| }; |
| return AotCompiler; |
| }()); |
| function _createEmptyStub(outputCtx) { |
| // Note: We need to produce at least one import statement so that |
| // TypeScript knows that the file is an es6 module. Otherwise our generated |
| // exports / imports won't be emitted properly by TypeScript. |
| outputCtx.statements.push(importExpr(Identifiers.ComponentFactory).toStmt()); |
| } |
| function _resolveStyleStatements(symbolResolver, compileResult, needsShim, fileSuffix) { |
| compileResult.dependencies.forEach(function (dep) { |
| dep.setValue(symbolResolver.getStaticSymbol(_stylesModuleUrl(dep.moduleUrl, needsShim, fileSuffix), dep.name)); |
| }); |
| } |
| function _stylesModuleUrl(stylesheetUrl, shim, suffix) { |
| return "" + stylesheetUrl + (shim ? '.shim' : '') + ".ngstyle" + suffix; |
| } |
| function analyzeNgModules(fileNames, host, staticSymbolResolver, metadataResolver) { |
| var files = _analyzeFilesIncludingNonProgramFiles(fileNames, host, staticSymbolResolver, metadataResolver); |
| return mergeAnalyzedFiles(files); |
| } |
| function analyzeAndValidateNgModules(fileNames, host, staticSymbolResolver, metadataResolver) { |
| return validateAnalyzedModules(analyzeNgModules(fileNames, host, staticSymbolResolver, metadataResolver)); |
| } |
| function validateAnalyzedModules(analyzedModules) { |
| if (analyzedModules.symbolsMissingModule && analyzedModules.symbolsMissingModule.length) { |
| var messages = analyzedModules.symbolsMissingModule.map(function (s) { |
| return "Cannot determine the module for class " + s.name + " in " + s.filePath + "! Add " + s.name + " to the NgModule to fix it."; |
| }); |
| throw syntaxError(messages.join('\n')); |
| } |
| return analyzedModules; |
| } |
| // Analyzes all of the program files, |
| // including files that are not part of the program |
| // but are referenced by an NgModule. |
| function _analyzeFilesIncludingNonProgramFiles(fileNames, host, staticSymbolResolver, metadataResolver) { |
| var seenFiles = new Set(); |
| var files = []; |
| var visitFile = function (fileName) { |
| if (seenFiles.has(fileName) || !host.isSourceFile(fileName)) { |
| return false; |
| } |
| seenFiles.add(fileName); |
| var analyzedFile = analyzeFile(host, staticSymbolResolver, metadataResolver, fileName); |
| files.push(analyzedFile); |
| analyzedFile.ngModules.forEach(function (ngModule) { |
| ngModule.transitiveModule.modules.forEach(function (modMeta) { return visitFile(modMeta.reference.filePath); }); |
| }); |
| }; |
| fileNames.forEach(function (fileName) { return visitFile(fileName); }); |
| return files; |
| } |
| function analyzeFile(host, staticSymbolResolver, metadataResolver, fileName) { |
| var directives = []; |
| var pipes = []; |
| var injectables = []; |
| var ngModules = []; |
| var hasDecorators = staticSymbolResolver.hasDecorators(fileName); |
| var exportsNonSourceFiles = false; |
| // Don't analyze .d.ts files that have no decorators as a shortcut |
| // to speed up the analysis. This prevents us from |
| // resolving the references in these files. |
| // Note: exportsNonSourceFiles is only needed when compiling with summaries, |
| // which is not the case when .d.ts files are treated as input files. |
| if (!fileName.endsWith('.d.ts') || hasDecorators) { |
| staticSymbolResolver.getSymbolsOf(fileName).forEach(function (symbol) { |
| var resolvedSymbol = staticSymbolResolver.resolveSymbol(symbol); |
| var symbolMeta = resolvedSymbol.metadata; |
| if (!symbolMeta || symbolMeta.__symbolic === 'error') { |
| return; |
| } |
| var isNgSymbol = false; |
| if (symbolMeta.__symbolic === 'class') { |
| if (metadataResolver.isDirective(symbol)) { |
| isNgSymbol = true; |
| directives.push(symbol); |
| } |
| else if (metadataResolver.isPipe(symbol)) { |
| isNgSymbol = true; |
| pipes.push(symbol); |
| } |
| else if (metadataResolver.isNgModule(symbol)) { |
| var ngModule = metadataResolver.getNgModuleMetadata(symbol, false); |
| if (ngModule) { |
| isNgSymbol = true; |
| ngModules.push(ngModule); |
| } |
| } |
| else if (metadataResolver.isInjectable(symbol)) { |
| isNgSymbol = true; |
| var injectable = metadataResolver.getInjectableMetadata(symbol, null, false); |
| if (injectable) { |
| injectables.push(injectable); |
| } |
| } |
| } |
| if (!isNgSymbol) { |
| exportsNonSourceFiles = |
| exportsNonSourceFiles || isValueExportingNonSourceFile(host, symbolMeta); |
| } |
| }); |
| } |
| return { |
| fileName: fileName, directives: directives, pipes: pipes, ngModules: ngModules, injectables: injectables, exportsNonSourceFiles: exportsNonSourceFiles, |
| }; |
| } |
| function analyzeFileForInjectables(host, staticSymbolResolver, metadataResolver, fileName) { |
| var injectables = []; |
| var shallowModules = []; |
| if (staticSymbolResolver.hasDecorators(fileName)) { |
| staticSymbolResolver.getSymbolsOf(fileName).forEach(function (symbol) { |
| var resolvedSymbol = staticSymbolResolver.resolveSymbol(symbol); |
| var symbolMeta = resolvedSymbol.metadata; |
| if (!symbolMeta || symbolMeta.__symbolic === 'error') { |
| return; |
| } |
| if (symbolMeta.__symbolic === 'class') { |
| if (metadataResolver.isInjectable(symbol)) { |
| var injectable = metadataResolver.getInjectableMetadata(symbol, null, false); |
| if (injectable) { |
| injectables.push(injectable); |
| } |
| } |
| else if (metadataResolver.isNgModule(symbol)) { |
| var module = metadataResolver.getShallowModuleMetadata(symbol); |
| if (module) { |
| shallowModules.push(module); |
| } |
| } |
| } |
| }); |
| } |
| return { fileName: fileName, injectables: injectables, shallowModules: shallowModules }; |
| } |
| function isValueExportingNonSourceFile(host, metadata) { |
| var exportsNonSourceFiles = false; |
| var Visitor = /** @class */ (function () { |
| function Visitor() { |
| } |
| Visitor.prototype.visitArray = function (arr, context) { |
| var _this = this; |
| arr.forEach(function (v) { return visitValue(v, _this, context); }); |
| }; |
| Visitor.prototype.visitStringMap = function (map, context) { |
| var _this = this; |
| Object.keys(map).forEach(function (key) { return visitValue(map[key], _this, context); }); |
| }; |
| Visitor.prototype.visitPrimitive = function (value, context) { }; |
| Visitor.prototype.visitOther = function (value, context) { |
| if (value instanceof StaticSymbol && !host.isSourceFile(value.filePath)) { |
| exportsNonSourceFiles = true; |
| } |
| }; |
| return Visitor; |
| }()); |
| visitValue(metadata, new Visitor(), null); |
| return exportsNonSourceFiles; |
| } |
| function mergeAnalyzedFiles(analyzedFiles) { |
| var allNgModules = []; |
| var ngModuleByPipeOrDirective = new Map(); |
| var allPipesAndDirectives = new Set(); |
| analyzedFiles.forEach(function (af) { |
| af.ngModules.forEach(function (ngModule) { |
| allNgModules.push(ngModule); |
| ngModule.declaredDirectives.forEach(function (d) { return ngModuleByPipeOrDirective.set(d.reference, ngModule); }); |
| ngModule.declaredPipes.forEach(function (p) { return ngModuleByPipeOrDirective.set(p.reference, ngModule); }); |
| }); |
| af.directives.forEach(function (d) { return allPipesAndDirectives.add(d); }); |
| af.pipes.forEach(function (p) { return allPipesAndDirectives.add(p); }); |
| }); |
| var symbolsMissingModule = []; |
| allPipesAndDirectives.forEach(function (ref) { |
| if (!ngModuleByPipeOrDirective.has(ref)) { |
| symbolsMissingModule.push(ref); |
| } |
| }); |
| return { |
| ngModules: allNgModules, |
| ngModuleByPipeOrDirective: ngModuleByPipeOrDirective, |
| symbolsMissingModule: symbolsMissingModule, |
| files: analyzedFiles |
| }; |
| } |
| function mergeAndValidateNgFiles(files) { |
| return validateAnalyzedModules(mergeAnalyzedFiles(files)); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var FORMATTED_MESSAGE = 'ngFormattedMessage'; |
| function indentStr(level) { |
| if (level <= 0) |
| return ''; |
| if (level < 6) |
| return ['', ' ', ' ', ' ', ' ', ' '][level]; |
| var half = indentStr(Math.floor(level / 2)); |
| return half + half + (level % 2 === 1 ? ' ' : ''); |
| } |
| function formatChain(chain, indent) { |
| if (indent === void 0) { indent = 0; } |
| if (!chain) |
| return ''; |
| var position = chain.position ? |
| chain.position.fileName + "(" + (chain.position.line + 1) + "," + (chain.position.column + 1) + ")" : |
| ''; |
| var prefix = position && indent === 0 ? position + ": " : ''; |
| var postfix = position && indent !== 0 ? " at " + position : ''; |
| var message = "" + prefix + chain.message + postfix; |
| return "" + indentStr(indent) + message + ((chain.next && ('\n' + formatChain(chain.next, indent + 2))) || ''); |
| } |
| function formattedError(chain) { |
| var message = formatChain(chain) + '.'; |
| var error = syntaxError(message); |
| error[FORMATTED_MESSAGE] = true; |
| error.chain = chain; |
| error.position = chain.position; |
| return error; |
| } |
| function isFormattedError(error) { |
| return !!error[FORMATTED_MESSAGE]; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var ANGULAR_CORE = '@angular/core'; |
| var ANGULAR_ROUTER = '@angular/router'; |
| var HIDDEN_KEY = /^\$.*\$$/; |
| var IGNORE = { |
| __symbolic: 'ignore' |
| }; |
| var USE_VALUE$1 = 'useValue'; |
| var PROVIDE = 'provide'; |
| var REFERENCE_SET = new Set([USE_VALUE$1, 'useFactory', 'data', 'id', 'loadChildren']); |
| var TYPEGUARD_POSTFIX = 'TypeGuard'; |
| var USE_IF = 'UseIf'; |
| function shouldIgnore(value) { |
| return value && value.__symbolic == 'ignore'; |
| } |
| /** |
| * A static reflector implements enough of the Reflector API that is necessary to compile |
| * templates statically. |
| */ |
| var StaticReflector = /** @class */ (function () { |
| function StaticReflector(summaryResolver, symbolResolver, knownMetadataClasses, knownMetadataFunctions, errorRecorder) { |
| var _this = this; |
| if (knownMetadataClasses === void 0) { knownMetadataClasses = []; } |
| if (knownMetadataFunctions === void 0) { knownMetadataFunctions = []; } |
| this.summaryResolver = summaryResolver; |
| this.symbolResolver = symbolResolver; |
| this.errorRecorder = errorRecorder; |
| this.annotationCache = new Map(); |
| this.shallowAnnotationCache = new Map(); |
| this.propertyCache = new Map(); |
| this.parameterCache = new Map(); |
| this.methodCache = new Map(); |
| this.staticCache = new Map(); |
| this.conversionMap = new Map(); |
| this.resolvedExternalReferences = new Map(); |
| this.annotationForParentClassWithSummaryKind = new Map(); |
| this.initializeConversionMap(); |
| knownMetadataClasses.forEach(function (kc) { return _this._registerDecoratorOrConstructor(_this.getStaticSymbol(kc.filePath, kc.name), kc.ctor); }); |
| knownMetadataFunctions.forEach(function (kf) { return _this._registerFunction(_this.getStaticSymbol(kf.filePath, kf.name), kf.fn); }); |
| this.annotationForParentClassWithSummaryKind.set(exports.CompileSummaryKind.Directive, [createDirective, createComponent]); |
| this.annotationForParentClassWithSummaryKind.set(exports.CompileSummaryKind.Pipe, [createPipe]); |
| this.annotationForParentClassWithSummaryKind.set(exports.CompileSummaryKind.NgModule, [createNgModule]); |
| this.annotationForParentClassWithSummaryKind.set(exports.CompileSummaryKind.Injectable, [createInjectable, createPipe, createDirective, createComponent, createNgModule]); |
| } |
| StaticReflector.prototype.componentModuleUrl = function (typeOrFunc) { |
| var staticSymbol = this.findSymbolDeclaration(typeOrFunc); |
| return this.symbolResolver.getResourcePath(staticSymbol); |
| }; |
| StaticReflector.prototype.resolveExternalReference = function (ref, containingFile) { |
| var key = undefined; |
| if (!containingFile) { |
| key = ref.moduleName + ":" + ref.name; |
| var declarationSymbol_1 = this.resolvedExternalReferences.get(key); |
| if (declarationSymbol_1) |
| return declarationSymbol_1; |
| } |
| var refSymbol = this.symbolResolver.getSymbolByModule(ref.moduleName, ref.name, containingFile); |
| var declarationSymbol = this.findSymbolDeclaration(refSymbol); |
| if (!containingFile) { |
| this.symbolResolver.recordModuleNameForFileName(refSymbol.filePath, ref.moduleName); |
| this.symbolResolver.recordImportAs(declarationSymbol, refSymbol); |
| } |
| if (key) { |
| this.resolvedExternalReferences.set(key, declarationSymbol); |
| } |
| return declarationSymbol; |
| }; |
| StaticReflector.prototype.findDeclaration = function (moduleUrl, name, containingFile) { |
| return this.findSymbolDeclaration(this.symbolResolver.getSymbolByModule(moduleUrl, name, containingFile)); |
| }; |
| StaticReflector.prototype.tryFindDeclaration = function (moduleUrl, name, containingFile) { |
| var _this = this; |
| return this.symbolResolver.ignoreErrorsFor(function () { return _this.findDeclaration(moduleUrl, name, containingFile); }); |
| }; |
| StaticReflector.prototype.findSymbolDeclaration = function (symbol) { |
| var resolvedSymbol = this.symbolResolver.resolveSymbol(symbol); |
| if (resolvedSymbol) { |
| var resolvedMetadata = resolvedSymbol.metadata; |
| if (resolvedMetadata && resolvedMetadata.__symbolic === 'resolved') { |
| resolvedMetadata = resolvedMetadata.symbol; |
| } |
| if (resolvedMetadata instanceof StaticSymbol) { |
| return this.findSymbolDeclaration(resolvedSymbol.metadata); |
| } |
| } |
| return symbol; |
| }; |
| StaticReflector.prototype.tryAnnotations = function (type) { |
| var originalRecorder = this.errorRecorder; |
| this.errorRecorder = function (error, fileName) { }; |
| try { |
| return this.annotations(type); |
| } |
| finally { |
| this.errorRecorder = originalRecorder; |
| } |
| }; |
| StaticReflector.prototype.annotations = function (type) { |
| var _this = this; |
| return this._annotations(type, function (type, decorators) { return _this.simplify(type, decorators); }, this.annotationCache); |
| }; |
| StaticReflector.prototype.shallowAnnotations = function (type) { |
| var _this = this; |
| return this._annotations(type, function (type, decorators) { return _this.simplify(type, decorators, true); }, this.shallowAnnotationCache); |
| }; |
| StaticReflector.prototype._annotations = function (type, simplify, annotationCache) { |
| var annotations = annotationCache.get(type); |
| if (!annotations) { |
| annotations = []; |
| var classMetadata = this.getTypeMetadata(type); |
| var parentType = this.findParentType(type, classMetadata); |
| if (parentType) { |
| var parentAnnotations = this.annotations(parentType); |
| annotations.push.apply(annotations, __spread(parentAnnotations)); |
| } |
| var ownAnnotations_1 = []; |
| if (classMetadata['decorators']) { |
| ownAnnotations_1 = simplify(type, classMetadata['decorators']); |
| if (ownAnnotations_1) { |
| annotations.push.apply(annotations, __spread(ownAnnotations_1)); |
| } |
| } |
| if (parentType && !this.summaryResolver.isLibraryFile(type.filePath) && |
| this.summaryResolver.isLibraryFile(parentType.filePath)) { |
| var summary = this.summaryResolver.resolveSummary(parentType); |
| if (summary && summary.type) { |
| var requiredAnnotationTypes = this.annotationForParentClassWithSummaryKind.get(summary.type.summaryKind); |
| var typeHasRequiredAnnotation = requiredAnnotationTypes.some(function (requiredType) { return ownAnnotations_1.some(function (ann) { return requiredType.isTypeOf(ann); }); }); |
| if (!typeHasRequiredAnnotation) { |
| this.reportError(formatMetadataError(metadataError("Class " + type.name + " in " + type.filePath + " extends from a " + exports.CompileSummaryKind[summary.type.summaryKind] + " in another compilation unit without duplicating the decorator", |
| /* summary */ undefined, "Please add a " + requiredAnnotationTypes.map(function (type) { return type.ngMetadataName; }).join(' or ') + " decorator to the class"), type), type); |
| } |
| } |
| } |
| annotationCache.set(type, annotations.filter(function (ann) { return !!ann; })); |
| } |
| return annotations; |
| }; |
| StaticReflector.prototype.propMetadata = function (type) { |
| var _this = this; |
| var propMetadata = this.propertyCache.get(type); |
| if (!propMetadata) { |
| var classMetadata = this.getTypeMetadata(type); |
| propMetadata = {}; |
| var parentType = this.findParentType(type, classMetadata); |
| if (parentType) { |
| var parentPropMetadata_1 = this.propMetadata(parentType); |
| Object.keys(parentPropMetadata_1).forEach(function (parentProp) { |
| propMetadata[parentProp] = parentPropMetadata_1[parentProp]; |
| }); |
| } |
| var members_1 = classMetadata['members'] || {}; |
| Object.keys(members_1).forEach(function (propName) { |
| var propData = members_1[propName]; |
| var prop = propData |
| .find(function (a) { return a['__symbolic'] == 'property' || a['__symbolic'] == 'method'; }); |
| var decorators = []; |
| if (propMetadata[propName]) { |
| decorators.push.apply(decorators, __spread(propMetadata[propName])); |
| } |
| propMetadata[propName] = decorators; |
| if (prop && prop['decorators']) { |
| decorators.push.apply(decorators, __spread(_this.simplify(type, prop['decorators']))); |
| } |
| }); |
| this.propertyCache.set(type, propMetadata); |
| } |
| return propMetadata; |
| }; |
| StaticReflector.prototype.parameters = function (type) { |
| var _this = this; |
| if (!(type instanceof StaticSymbol)) { |
| this.reportError(new Error("parameters received " + JSON.stringify(type) + " which is not a StaticSymbol"), type); |
| return []; |
| } |
| try { |
| var parameters_1 = this.parameterCache.get(type); |
| if (!parameters_1) { |
| var classMetadata = this.getTypeMetadata(type); |
| var parentType = this.findParentType(type, classMetadata); |
| var members = classMetadata ? classMetadata['members'] : null; |
| var ctorData = members ? members['__ctor__'] : null; |
| if (ctorData) { |
| var ctor = ctorData.find(function (a) { return a['__symbolic'] == 'constructor'; }); |
| var rawParameterTypes = ctor['parameters'] || []; |
| var parameterDecorators_1 = this.simplify(type, ctor['parameterDecorators'] || []); |
| parameters_1 = []; |
| rawParameterTypes.forEach(function (rawParamType, index) { |
| var nestedResult = []; |
| var paramType = _this.trySimplify(type, rawParamType); |
| if (paramType) |
| nestedResult.push(paramType); |
| var decorators = parameterDecorators_1 ? parameterDecorators_1[index] : null; |
| if (decorators) { |
| nestedResult.push.apply(nestedResult, __spread(decorators)); |
| } |
| parameters_1.push(nestedResult); |
| }); |
| } |
| else if (parentType) { |
| parameters_1 = this.parameters(parentType); |
| } |
| if (!parameters_1) { |
| parameters_1 = []; |
| } |
| this.parameterCache.set(type, parameters_1); |
| } |
| return parameters_1; |
| } |
| catch (e) { |
| console.error("Failed on type " + JSON.stringify(type) + " with error " + e); |
| throw e; |
| } |
| }; |
| StaticReflector.prototype._methodNames = function (type) { |
| var methodNames = this.methodCache.get(type); |
| if (!methodNames) { |
| var classMetadata = this.getTypeMetadata(type); |
| methodNames = {}; |
| var parentType = this.findParentType(type, classMetadata); |
| if (parentType) { |
| var parentMethodNames_1 = this._methodNames(parentType); |
| Object.keys(parentMethodNames_1).forEach(function (parentProp) { |
| methodNames[parentProp] = parentMethodNames_1[parentProp]; |
| }); |
| } |
| var members_2 = classMetadata['members'] || {}; |
| Object.keys(members_2).forEach(function (propName) { |
| var propData = members_2[propName]; |
| var isMethod = propData.some(function (a) { return a['__symbolic'] == 'method'; }); |
| methodNames[propName] = methodNames[propName] || isMethod; |
| }); |
| this.methodCache.set(type, methodNames); |
| } |
| return methodNames; |
| }; |
| StaticReflector.prototype._staticMembers = function (type) { |
| var staticMembers = this.staticCache.get(type); |
| if (!staticMembers) { |
| var classMetadata = this.getTypeMetadata(type); |
| var staticMemberData = classMetadata['statics'] || {}; |
| staticMembers = Object.keys(staticMemberData); |
| this.staticCache.set(type, staticMembers); |
| } |
| return staticMembers; |
| }; |
| StaticReflector.prototype.findParentType = function (type, classMetadata) { |
| var parentType = this.trySimplify(type, classMetadata['extends']); |
| if (parentType instanceof StaticSymbol) { |
| return parentType; |
| } |
| }; |
| StaticReflector.prototype.hasLifecycleHook = function (type, lcProperty) { |
| if (!(type instanceof StaticSymbol)) { |
| this.reportError(new Error("hasLifecycleHook received " + JSON.stringify(type) + " which is not a StaticSymbol"), type); |
| } |
| try { |
| return !!this._methodNames(type)[lcProperty]; |
| } |
| catch (e) { |
| console.error("Failed on type " + JSON.stringify(type) + " with error " + e); |
| throw e; |
| } |
| }; |
| StaticReflector.prototype.guards = function (type) { |
| var e_1, _a; |
| if (!(type instanceof StaticSymbol)) { |
| this.reportError(new Error("guards received " + JSON.stringify(type) + " which is not a StaticSymbol"), type); |
| return {}; |
| } |
| var staticMembers = this._staticMembers(type); |
| var result = {}; |
| try { |
| for (var staticMembers_1 = __values(staticMembers), staticMembers_1_1 = staticMembers_1.next(); !staticMembers_1_1.done; staticMembers_1_1 = staticMembers_1.next()) { |
| var name_1 = staticMembers_1_1.value; |
| if (name_1.endsWith(TYPEGUARD_POSTFIX)) { |
| var property = name_1.substr(0, name_1.length - TYPEGUARD_POSTFIX.length); |
| var value = void 0; |
| if (property.endsWith(USE_IF)) { |
| property = name_1.substr(0, property.length - USE_IF.length); |
| value = USE_IF; |
| } |
| else { |
| value = this.getStaticSymbol(type.filePath, type.name, [name_1]); |
| } |
| result[property] = value; |
| } |
| } |
| } |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } |
| finally { |
| try { |
| if (staticMembers_1_1 && !staticMembers_1_1.done && (_a = staticMembers_1.return)) _a.call(staticMembers_1); |
| } |
| finally { if (e_1) throw e_1.error; } |
| } |
| return result; |
| }; |
| StaticReflector.prototype._registerDecoratorOrConstructor = function (type, ctor) { |
| this.conversionMap.set(type, function (context, args) { return new (ctor.bind.apply(ctor, __spread([void 0], args)))(); }); |
| }; |
| StaticReflector.prototype._registerFunction = function (type, fn) { |
| this.conversionMap.set(type, function (context, args) { return fn.apply(undefined, args); }); |
| }; |
| StaticReflector.prototype.initializeConversionMap = function () { |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Injectable'), createInjectable); |
| this.injectionToken = this.findDeclaration(ANGULAR_CORE, 'InjectionToken'); |
| this.opaqueToken = this.findDeclaration(ANGULAR_CORE, 'OpaqueToken'); |
| this.ROUTES = this.tryFindDeclaration(ANGULAR_ROUTER, 'ROUTES'); |
| this.ANALYZE_FOR_ENTRY_COMPONENTS = |
| this.findDeclaration(ANGULAR_CORE, 'ANALYZE_FOR_ENTRY_COMPONENTS'); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Host'), createHost); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Self'), createSelf); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'SkipSelf'), createSkipSelf); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Inject'), createInject); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Optional'), createOptional); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Attribute'), createAttribute); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'ContentChild'), createContentChild); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'ContentChildren'), createContentChildren); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'ViewChild'), createViewChild); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'ViewChildren'), createViewChildren); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Input'), createInput); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Output'), createOutput); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Pipe'), createPipe); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'HostBinding'), createHostBinding); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'HostListener'), createHostListener); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Directive'), createDirective); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Component'), createComponent); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'NgModule'), createNgModule); |
| // Note: Some metadata classes can be used directly with Provider.deps. |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Host'), createHost); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Self'), createSelf); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'SkipSelf'), createSkipSelf); |
| this._registerDecoratorOrConstructor(this.findDeclaration(ANGULAR_CORE, 'Optional'), createOptional); |
| }; |
| /** |
| * getStaticSymbol produces a Type whose metadata is known but whose implementation is not loaded. |
| * All types passed to the StaticResolver should be pseudo-types returned by this method. |
| * |
| * @param declarationFile the absolute path of the file where the symbol is declared |
| * @param name the name of the type. |
| */ |
| StaticReflector.prototype.getStaticSymbol = function (declarationFile, name, members) { |
| return this.symbolResolver.getStaticSymbol(declarationFile, name, members); |
| }; |
| /** |
| * Simplify but discard any errors |
| */ |
| StaticReflector.prototype.trySimplify = function (context, value) { |
| var originalRecorder = this.errorRecorder; |
| this.errorRecorder = function (error, fileName) { }; |
| var result = this.simplify(context, value); |
| this.errorRecorder = originalRecorder; |
| return result; |
| }; |
| /** @internal */ |
| StaticReflector.prototype.simplify = function (context, value, lazy) { |
| if (lazy === void 0) { lazy = false; } |
| var self = this; |
| var scope = BindingScope$1.empty; |
| var calling = new Map(); |
| function simplifyInContext(context, value, depth, references) { |
| function resolveReferenceValue(staticSymbol) { |
| var resolvedSymbol = self.symbolResolver.resolveSymbol(staticSymbol); |
| return resolvedSymbol ? resolvedSymbol.metadata : null; |
| } |
| function simplifyEagerly(value) { |
| return simplifyInContext(context, value, depth, 0); |
| } |
| function simplifyLazily(value) { |
| return simplifyInContext(context, value, depth, references + 1); |
| } |
| function simplifyNested(nestedContext, value) { |
| if (nestedContext === context) { |
| // If the context hasn't changed let the exception propagate unmodified. |
| return simplifyInContext(nestedContext, value, depth + 1, references); |
| } |
| try { |
| return simplifyInContext(nestedContext, value, depth + 1, references); |
| } |
| catch (e) { |
| if (isMetadataError(e)) { |
| // Propagate the message text up but add a message to the chain that explains how we got |
| // here. |
| // e.chain implies e.symbol |
| var summaryMsg = e.chain ? 'references \'' + e.symbol.name + '\'' : errorSummary(e); |
| var summary = "'" + nestedContext.name + "' " + summaryMsg; |
| var chain = { message: summary, position: e.position, next: e.chain }; |
| // TODO(chuckj): retrieve the position information indirectly from the collectors node |
| // map if the metadata is from a .ts file. |
| self.error({ |
| message: e.message, |
| advise: e.advise, |
| context: e.context, chain: chain, |
| symbol: nestedContext |
| }, context); |
| } |
| else { |
| // It is probably an internal error. |
| throw e; |
| } |
| } |
| } |
| function simplifyCall(functionSymbol, targetFunction, args, targetExpression) { |
| if (targetFunction && targetFunction['__symbolic'] == 'function') { |
| if (calling.get(functionSymbol)) { |
| self.error({ |
| message: 'Recursion is not supported', |
| summary: "called '" + functionSymbol.name + "' recursively", |
| value: targetFunction |
| }, functionSymbol); |
| } |
| try { |
| var value_1 = targetFunction['value']; |
| if (value_1 && (depth != 0 || value_1.__symbolic != 'error')) { |
| var parameters = targetFunction['parameters']; |
| var defaults = targetFunction.defaults; |
| args = args.map(function (arg) { return simplifyNested(context, arg); }) |
| .map(function (arg) { return shouldIgnore(arg) ? undefined : arg; }); |
| if (defaults && defaults.length > args.length) { |
| args.push.apply(args, __spread(defaults.slice(args.length).map(function (value) { return simplify(value); }))); |
| } |
| calling.set(functionSymbol, true); |
| var functionScope = BindingScope$1.build(); |
| for (var i = 0; i < parameters.length; i++) { |
| functionScope.define(parameters[i], args[i]); |
| } |
| var oldScope = scope; |
| var result_1; |
| try { |
| scope = functionScope.done(); |
| result_1 = simplifyNested(functionSymbol, value_1); |
| } |
| finally { |
| scope = oldScope; |
| } |
| return result_1; |
| } |
| } |
| finally { |
| calling.delete(functionSymbol); |
| } |
| } |
| if (depth === 0) { |
| // If depth is 0 we are evaluating the top level expression that is describing element |
| // decorator. In this case, it is a decorator we don't understand, such as a custom |
| // non-angular decorator, and we should just ignore it. |
| return IGNORE; |
| } |
| var position = undefined; |
| if (targetExpression && targetExpression.__symbolic == 'resolved') { |
| var line = targetExpression.line; |
| var character = targetExpression.character; |
| var fileName = targetExpression.fileName; |
| if (fileName != null && line != null && character != null) { |
| position = { fileName: fileName, line: line, column: character }; |
| } |
| } |
| self.error({ |
| message: FUNCTION_CALL_NOT_SUPPORTED, |
| context: functionSymbol, |
| value: targetFunction, position: position |
| }, context); |
| } |
| function simplify(expression) { |
| var e_2, _a, e_3, _b; |
| if (isPrimitive(expression)) { |
| return expression; |
| } |
| if (expression instanceof Array) { |
| var result_2 = []; |
| try { |
| for (var _c = __values(expression), _d = _c.next(); !_d.done; _d = _c.next()) { |
| var item = _d.value; |
| // Check for a spread expression |
| if (item && item.__symbolic === 'spread') { |
| // We call with references as 0 because we require the actual value and cannot |
| // tolerate a reference here. |
| var spreadArray = simplifyEagerly(item.expression); |
| if (Array.isArray(spreadArray)) { |
| try { |
| for (var spreadArray_1 = __values(spreadArray), spreadArray_1_1 = spreadArray_1.next(); !spreadArray_1_1.done; spreadArray_1_1 = spreadArray_1.next()) { |
| var spreadItem = spreadArray_1_1.value; |
| result_2.push(spreadItem); |
| } |
| } |
| catch (e_3_1) { e_3 = { error: e_3_1 }; } |
| finally { |
| try { |
| if (spreadArray_1_1 && !spreadArray_1_1.done && (_b = spreadArray_1.return)) _b.call(spreadArray_1); |
| } |
| finally { if (e_3) throw e_3.error; } |
| } |
| continue; |
| } |
| } |
| var value_2 = simplify(item); |
| if (shouldIgnore(value_2)) { |
| continue; |
| } |
| result_2.push(value_2); |
| } |
| } |
| catch (e_2_1) { e_2 = { error: e_2_1 }; } |
| finally { |
| try { |
| if (_d && !_d.done && (_a = _c.return)) _a.call(_c); |
| } |
| finally { if (e_2) throw e_2.error; } |
| } |
| return result_2; |
| } |
| if (expression instanceof StaticSymbol) { |
| // Stop simplification at builtin symbols or if we are in a reference context and |
| // the symbol doesn't have members. |
| if (expression === self.injectionToken || self.conversionMap.has(expression) || |
| (references > 0 && !expression.members.length)) { |
| return expression; |
| } |
| else { |
| var staticSymbol = expression; |
| var declarationValue = resolveReferenceValue(staticSymbol); |
| if (declarationValue != null) { |
| return simplifyNested(staticSymbol, declarationValue); |
| } |
| else { |
| return staticSymbol; |
| } |
| } |
| } |
| if (expression) { |
| if (expression['__symbolic']) { |
| var staticSymbol = void 0; |
| switch (expression['__symbolic']) { |
| case 'binop': |
| var left = simplify(expression['left']); |
| if (shouldIgnore(left)) |
| return left; |
| var right = simplify(expression['right']); |
| if (shouldIgnore(right)) |
| return right; |
| switch (expression['operator']) { |
| case '&&': |
| return left && right; |
| case '||': |
| return left || right; |
| case '|': |
| return left | right; |
| case '^': |
| return left ^ right; |
| case '&': |
| return left & right; |
| case '==': |
| return left == right; |
| case '!=': |
| return left != right; |
| case '===': |
| return left === right; |
| case '!==': |
| return left !== right; |
| case '<': |
| return left < right; |
| case '>': |
| return left > right; |
| case '<=': |
| return left <= right; |
| case '>=': |
| return left >= right; |
| case '<<': |
| return left << right; |
| case '>>': |
| return left >> right; |
| case '+': |
| return left + right; |
| case '-': |
| return left - right; |
| case '*': |
| return left * right; |
| case '/': |
| return left / right; |
| case '%': |
| return left % right; |
| } |
| return null; |
| case 'if': |
| var condition = simplify(expression['condition']); |
| return condition ? simplify(expression['thenExpression']) : |
| simplify(expression['elseExpression']); |
| case 'pre': |
| var operand = simplify(expression['operand']); |
| if (shouldIgnore(operand)) |
| return operand; |
| switch (expression['operator']) { |
| case '+': |
| return operand; |
| case '-': |
| return -operand; |
| case '!': |
| return !operand; |
| case '~': |
| return ~operand; |
| } |
| return null; |
| case 'index': |
| var indexTarget = simplifyEagerly(expression['expression']); |
| var index = simplifyEagerly(expression['index']); |
| if (indexTarget && isPrimitive(index)) |
| return indexTarget[index]; |
| return null; |
| case 'select': |
| var member = expression['member']; |
| var selectContext = context; |
| var selectTarget = simplify(expression['expression']); |
| if (selectTarget instanceof StaticSymbol) { |
| var members = selectTarget.members.concat(member); |
| selectContext = |
| self.getStaticSymbol(selectTarget.filePath, selectTarget.name, members); |
| var declarationValue = resolveReferenceValue(selectContext); |
| if (declarationValue != null) { |
| return simplifyNested(selectContext, declarationValue); |
| } |
| else { |
| return selectContext; |
| } |
| } |
| if (selectTarget && isPrimitive(member)) |
| return simplifyNested(selectContext, selectTarget[member]); |
| return null; |
| case 'reference': |
| // Note: This only has to deal with variable references, as symbol references have |
| // been converted into 'resolved' |
| // in the StaticSymbolResolver. |
| var name_2 = expression['name']; |
| var localValue = scope.resolve(name_2); |
| if (localValue != BindingScope$1.missing) { |
| return localValue; |
| } |
| break; |
| case 'resolved': |
| try { |
| return simplify(expression.symbol); |
| } |
| catch (e) { |
| // If an error is reported evaluating the symbol record the position of the |
| // reference in the error so it can |
| // be reported in the error message generated from the exception. |
| if (isMetadataError(e) && expression.fileName != null && |
| expression.line != null && expression.character != null) { |
| e.position = { |
| fileName: expression.fileName, |
| line: expression.line, |
| column: expression.character |
| }; |
| } |
| throw e; |
| } |
| case 'class': |
| return context; |
| case 'function': |
| return context; |
| case 'new': |
| case 'call': |
| // Determine if the function is a built-in conversion |
| staticSymbol = simplifyInContext(context, expression['expression'], depth + 1, /* references */ 0); |
| if (staticSymbol instanceof StaticSymbol) { |
| if (staticSymbol === self.injectionToken || staticSymbol === self.opaqueToken) { |
| // if somebody calls new InjectionToken, don't create an InjectionToken, |
| // but rather return the symbol to which the InjectionToken is assigned to. |
| // OpaqueToken is supported too as it is required by the language service to |
| // support v4 and prior versions of Angular. |
| return context; |
| } |
| var argExpressions = expression['arguments'] || []; |
| var converter = self.conversionMap.get(staticSymbol); |
| if (converter) { |
| var args = argExpressions.map(function (arg) { return simplifyNested(context, arg); }) |
| .map(function (arg) { return shouldIgnore(arg) ? undefined : arg; }); |
| return converter(context, args); |
| } |
| else { |
| // Determine if the function is one we can simplify. |
| var targetFunction = resolveReferenceValue(staticSymbol); |
| return simplifyCall(staticSymbol, targetFunction, argExpressions, expression['expression']); |
| } |
| } |
| return IGNORE; |
| case 'error': |
| var message = expression.message; |
| if (expression['line'] != null) { |
| self.error({ |
| message: message, |
| context: expression.context, |
| value: expression, |
| position: { |
| fileName: expression['fileName'], |
| line: expression['line'], |
| column: expression['character'] |
| } |
| }, context); |
| } |
| else { |
| self.error({ message: message, context: expression.context }, context); |
| } |
| return IGNORE; |
| case 'ignore': |
| return expression; |
| } |
| return null; |
| } |
| return mapStringMap(expression, function (value, name) { |
| if (REFERENCE_SET.has(name)) { |
| if (name === USE_VALUE$1 && PROVIDE in expression) { |
| // If this is a provider expression, check for special tokens that need the value |
| // during analysis. |
| var provide = simplify(expression.provide); |
| if (provide === self.ROUTES || provide == self.ANALYZE_FOR_ENTRY_COMPONENTS) { |
| return simplify(value); |
| } |
| } |
| return simplifyLazily(value); |
| } |
| return simplify(value); |
| }); |
| } |
| return IGNORE; |
| } |
| return simplify(value); |
| } |
| var result; |
| try { |
| result = simplifyInContext(context, value, 0, lazy ? 1 : 0); |
| } |
| catch (e) { |
| if (this.errorRecorder) { |
| this.reportError(e, context); |
| } |
| else { |
| throw formatMetadataError(e, context); |
| } |
| } |
| if (shouldIgnore(result)) { |
| return undefined; |
| } |
| return result; |
| }; |
| StaticReflector.prototype.getTypeMetadata = function (type) { |
| var resolvedSymbol = this.symbolResolver.resolveSymbol(type); |
| return resolvedSymbol && resolvedSymbol.metadata ? resolvedSymbol.metadata : |
| { __symbolic: 'class' }; |
| }; |
| StaticReflector.prototype.reportError = function (error, context, path) { |
| if (this.errorRecorder) { |
| this.errorRecorder(formatMetadataError(error, context), (context && context.filePath) || path); |
| } |
| else { |
| throw error; |
| } |
| }; |
| StaticReflector.prototype.error = function (_a, reportingContext) { |
| var message = _a.message, summary = _a.summary, advise = _a.advise, position = _a.position, context = _a.context, value = _a.value, symbol = _a.symbol, chain = _a.chain; |
| this.reportError(metadataError(message, summary, advise, position, symbol, context, chain), reportingContext); |
| }; |
| return StaticReflector; |
| }()); |
| var METADATA_ERROR = 'ngMetadataError'; |
| function metadataError(message, summary, advise, position, symbol, context, chain) { |
| var error = syntaxError(message); |
| error[METADATA_ERROR] = true; |
| if (advise) |
| error.advise = advise; |
| if (position) |
| error.position = position; |
| if (summary) |
| error.summary = summary; |
| if (context) |
| error.context = context; |
| if (chain) |
| error.chain = chain; |
| if (symbol) |
| error.symbol = symbol; |
| return error; |
| } |
| function isMetadataError(error) { |
| return !!error[METADATA_ERROR]; |
| } |
| var REFERENCE_TO_NONEXPORTED_CLASS = 'Reference to non-exported class'; |
| var VARIABLE_NOT_INITIALIZED = 'Variable not initialized'; |
| var DESTRUCTURE_NOT_SUPPORTED = 'Destructuring not supported'; |
| var COULD_NOT_RESOLVE_TYPE = 'Could not resolve type'; |
| var FUNCTION_CALL_NOT_SUPPORTED = 'Function call not supported'; |
| var REFERENCE_TO_LOCAL_SYMBOL = 'Reference to a local symbol'; |
| var LAMBDA_NOT_SUPPORTED = 'Lambda not supported'; |
| function expandedMessage(message, context) { |
| switch (message) { |
| case REFERENCE_TO_NONEXPORTED_CLASS: |
| if (context && context.className) { |
| return "References to a non-exported class are not supported in decorators but " + context.className + " was referenced."; |
| } |
| break; |
| case VARIABLE_NOT_INITIALIZED: |
| return 'Only initialized variables and constants can be referenced in decorators because the value of this variable is needed by the template compiler'; |
| case DESTRUCTURE_NOT_SUPPORTED: |
| return 'Referencing an exported destructured variable or constant is not supported in decorators and this value is needed by the template compiler'; |
| case COULD_NOT_RESOLVE_TYPE: |
| if (context && context.typeName) { |
| return "Could not resolve type " + context.typeName; |
| } |
| break; |
| case FUNCTION_CALL_NOT_SUPPORTED: |
| if (context && context.name) { |
| return "Function calls are not supported in decorators but '" + context.name + "' was called"; |
| } |
| return 'Function calls are not supported in decorators'; |
| case REFERENCE_TO_LOCAL_SYMBOL: |
| if (context && context.name) { |
| return "Reference to a local (non-exported) symbols are not supported in decorators but '" + context.name + "' was referenced"; |
| } |
| break; |
| case LAMBDA_NOT_SUPPORTED: |
| return "Function expressions are not supported in decorators"; |
| } |
| return message; |
| } |
| function messageAdvise(message, context) { |
| switch (message) { |
| case REFERENCE_TO_NONEXPORTED_CLASS: |
| if (context && context.className) { |
| return "Consider exporting '" + context.className + "'"; |
| } |
| break; |
| case DESTRUCTURE_NOT_SUPPORTED: |
| return 'Consider simplifying to avoid destructuring'; |
| case REFERENCE_TO_LOCAL_SYMBOL: |
| if (context && context.name) { |
| return "Consider exporting '" + context.name + "'"; |
| } |
| break; |
| case LAMBDA_NOT_SUPPORTED: |
| return "Consider changing the function expression into an exported function"; |
| } |
| return undefined; |
| } |
| function errorSummary(error) { |
| if (error.summary) { |
| return error.summary; |
| } |
| switch (error.message) { |
| case REFERENCE_TO_NONEXPORTED_CLASS: |
| if (error.context && error.context.className) { |
| return "references non-exported class " + error.context.className; |
| } |
| break; |
| case VARIABLE_NOT_INITIALIZED: |
| return 'is not initialized'; |
| case DESTRUCTURE_NOT_SUPPORTED: |
| return 'is a destructured variable'; |
| case COULD_NOT_RESOLVE_TYPE: |
| return 'could not be resolved'; |
| case FUNCTION_CALL_NOT_SUPPORTED: |
| if (error.context && error.context.name) { |
| return "calls '" + error.context.name + "'"; |
| } |
| return "calls a function"; |
| case REFERENCE_TO_LOCAL_SYMBOL: |
| if (error.context && error.context.name) { |
| return "references local variable " + error.context.name; |
| } |
| return "references a local variable"; |
| } |
| return 'contains the error'; |
| } |
| function mapStringMap(input, transform) { |
| if (!input) |
| return {}; |
| var result = {}; |
| Object.keys(input).forEach(function (key) { |
| var value = transform(input[key], key); |
| if (!shouldIgnore(value)) { |
| if (HIDDEN_KEY.test(key)) { |
| Object.defineProperty(result, key, { enumerable: false, configurable: true, value: value }); |
| } |
| else { |
| result[key] = value; |
| } |
| } |
| }); |
| return result; |
| } |
| function isPrimitive(o) { |
| return o === null || (typeof o !== 'function' && typeof o !== 'object'); |
| } |
| var BindingScope$1 = /** @class */ (function () { |
| function BindingScope() { |
| } |
| BindingScope.build = function () { |
| var current = new Map(); |
| return { |
| define: function (name, value) { |
| current.set(name, value); |
| return this; |
| }, |
| done: function () { |
| return current.size > 0 ? new PopulatedScope(current) : BindingScope.empty; |
| } |
| }; |
| }; |
| BindingScope.missing = {}; |
| BindingScope.empty = { resolve: function (name) { return BindingScope.missing; } }; |
| return BindingScope; |
| }()); |
| var PopulatedScope = /** @class */ (function (_super) { |
| __extends(PopulatedScope, _super); |
| function PopulatedScope(bindings) { |
| var _this = _super.call(this) || this; |
| _this.bindings = bindings; |
| return _this; |
| } |
| PopulatedScope.prototype.resolve = function (name) { |
| return this.bindings.has(name) ? this.bindings.get(name) : BindingScope$1.missing; |
| }; |
| return PopulatedScope; |
| }(BindingScope$1)); |
| function formatMetadataMessageChain(chain, advise) { |
| var expanded = expandedMessage(chain.message, chain.context); |
| var nesting = chain.symbol ? " in '" + chain.symbol.name + "'" : ''; |
| var message = "" + expanded + nesting; |
| var position = chain.position; |
| var next = chain.next ? |
| formatMetadataMessageChain(chain.next, advise) : |
| advise ? { message: advise } : undefined; |
| return { message: message, position: position, next: next }; |
| } |
| function formatMetadataError(e, context) { |
| if (isMetadataError(e)) { |
| // Produce a formatted version of the and leaving enough information in the original error |
| // to recover the formatting information to eventually produce a diagnostic error message. |
| var position = e.position; |
| var chain = { |
| message: "Error during template compile of '" + context.name + "'", |
| position: position, |
| next: { message: e.message, next: e.chain, context: e.context, symbol: e.symbol } |
| }; |
| var advise = e.advise || messageAdvise(e.message, e.context); |
| return formattedError(formatMetadataMessageChain(chain, advise)); |
| } |
| return e; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var AotSummaryResolver = /** @class */ (function () { |
| function AotSummaryResolver(host, staticSymbolCache) { |
| this.host = host; |
| this.staticSymbolCache = staticSymbolCache; |
| // Note: this will only contain StaticSymbols without members! |
| this.summaryCache = new Map(); |
| this.loadedFilePaths = new Map(); |
| // Note: this will only contain StaticSymbols without members! |
| this.importAs = new Map(); |
| this.knownFileNameToModuleNames = new Map(); |
| } |
| AotSummaryResolver.prototype.isLibraryFile = function (filePath) { |
| // Note: We need to strip the .ngfactory. file path, |
| // so this method also works for generated files |
| // (for which host.isSourceFile will always return false). |
| return !this.host.isSourceFile(stripGeneratedFileSuffix(filePath)); |
| }; |
| AotSummaryResolver.prototype.toSummaryFileName = function (filePath, referringSrcFileName) { |
| return this.host.toSummaryFileName(filePath, referringSrcFileName); |
| }; |
| AotSummaryResolver.prototype.fromSummaryFileName = function (fileName, referringLibFileName) { |
| return this.host.fromSummaryFileName(fileName, referringLibFileName); |
| }; |
| AotSummaryResolver.prototype.resolveSummary = function (staticSymbol) { |
| var rootSymbol = staticSymbol.members.length ? |
| this.staticSymbolCache.get(staticSymbol.filePath, staticSymbol.name) : |
| staticSymbol; |
| var summary = this.summaryCache.get(rootSymbol); |
| if (!summary) { |
| this._loadSummaryFile(staticSymbol.filePath); |
| summary = this.summaryCache.get(staticSymbol); |
| } |
| return (rootSymbol === staticSymbol && summary) || null; |
| }; |
| AotSummaryResolver.prototype.getSymbolsOf = function (filePath) { |
| if (this._loadSummaryFile(filePath)) { |
| return Array.from(this.summaryCache.keys()).filter(function (symbol) { return symbol.filePath === filePath; }); |
| } |
| return null; |
| }; |
| AotSummaryResolver.prototype.getImportAs = function (staticSymbol) { |
| staticSymbol.assertNoMembers(); |
| return this.importAs.get(staticSymbol); |
| }; |
| /** |
| * Converts a file path to a module name that can be used as an `import`. |
| */ |
| AotSummaryResolver.prototype.getKnownModuleName = function (importedFilePath) { |
| return this.knownFileNameToModuleNames.get(importedFilePath) || null; |
| }; |
| AotSummaryResolver.prototype.addSummary = function (summary) { this.summaryCache.set(summary.symbol, summary); }; |
| AotSummaryResolver.prototype._loadSummaryFile = function (filePath) { |
| var _this = this; |
| var hasSummary = this.loadedFilePaths.get(filePath); |
| if (hasSummary != null) { |
| return hasSummary; |
| } |
| var json = null; |
| if (this.isLibraryFile(filePath)) { |
| var summaryFilePath = summaryFileName(filePath); |
| try { |
| json = this.host.loadSummary(summaryFilePath); |
| } |
| catch (e) { |
| console.error("Error loading summary file " + summaryFilePath); |
| throw e; |
| } |
| } |
| hasSummary = json != null; |
| this.loadedFilePaths.set(filePath, hasSummary); |
| if (json) { |
| var _a = deserializeSummaries(this.staticSymbolCache, this, filePath, json), moduleName = _a.moduleName, summaries = _a.summaries, importAs = _a.importAs; |
| summaries.forEach(function (summary) { return _this.summaryCache.set(summary.symbol, summary); }); |
| if (moduleName) { |
| this.knownFileNameToModuleNames.set(filePath, moduleName); |
| } |
| importAs.forEach(function (importAs) { _this.importAs.set(importAs.symbol, importAs.importAs); }); |
| } |
| return hasSummary; |
| }; |
| return AotSummaryResolver; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| function createAotUrlResolver(host) { |
| return { |
| resolve: function (basePath, url) { |
| var filePath = host.resourceNameToFileName(url, basePath); |
| if (!filePath) { |
| throw syntaxError("Couldn't resolve resource " + url + " from " + basePath); |
| } |
| return filePath; |
| } |
| }; |
| } |
| /** |
| * Creates a new AotCompiler based on options and a host. |
| */ |
| function createAotCompiler(compilerHost, options, errorCollector) { |
| var translations = options.translations || ''; |
| var urlResolver = createAotUrlResolver(compilerHost); |
| var symbolCache = new StaticSymbolCache(); |
| var summaryResolver = new AotSummaryResolver(compilerHost, symbolCache); |
| var symbolResolver = new StaticSymbolResolver(compilerHost, symbolCache, summaryResolver); |
| var staticReflector = new StaticReflector(summaryResolver, symbolResolver, [], [], errorCollector); |
| var htmlParser; |
| if (!!options.enableIvy) { |
| // Ivy handles i18n at the compiler level so we must use a regular parser |
| htmlParser = new HtmlParser(); |
| } |
| else { |
| htmlParser = new I18NHtmlParser(new HtmlParser(), translations, options.i18nFormat, options.missingTranslation, console); |
| } |
| var config = new CompilerConfig({ |
| defaultEncapsulation: ViewEncapsulation.Emulated, |
| useJit: false, |
| missingTranslation: options.missingTranslation, |
| preserveWhitespaces: options.preserveWhitespaces, |
| strictInjectionParameters: options.strictInjectionParameters, |
| }); |
| var normalizer = new DirectiveNormalizer({ get: function (url) { return compilerHost.loadResource(url); } }, urlResolver, htmlParser, config); |
| var expressionParser = new Parser$1(new Lexer()); |
| var elementSchemaRegistry = new DomElementSchemaRegistry(); |
| var tmplParser = new TemplateParser(config, staticReflector, expressionParser, elementSchemaRegistry, htmlParser, console, []); |
| var resolver = new CompileMetadataResolver(config, htmlParser, new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector), new PipeResolver(staticReflector), summaryResolver, elementSchemaRegistry, normalizer, console, symbolCache, staticReflector, errorCollector); |
| // TODO(vicb): do not pass options.i18nFormat here |
| var viewCompiler = new ViewCompiler(staticReflector); |
| var typeCheckCompiler = new TypeCheckCompiler(options, staticReflector); |
| var compiler = new AotCompiler(config, options, compilerHost, staticReflector, resolver, tmplParser, new StyleCompiler(urlResolver), viewCompiler, typeCheckCompiler, new NgModuleCompiler(staticReflector), new InjectableCompiler(staticReflector, !!options.enableIvy), new TypeScriptEmitter(), summaryResolver, symbolResolver); |
| return { compiler: compiler, reflector: staticReflector }; |
| } |
| |
| var SummaryResolver = /** @class */ (function () { |
| function SummaryResolver() { |
| } |
| return SummaryResolver; |
| }()); |
| var JitSummaryResolver = /** @class */ (function () { |
| function JitSummaryResolver() { |
| this._summaries = new Map(); |
| } |
| JitSummaryResolver.prototype.isLibraryFile = function () { return false; }; |
| JitSummaryResolver.prototype.toSummaryFileName = function (fileName) { return fileName; }; |
| JitSummaryResolver.prototype.fromSummaryFileName = function (fileName) { return fileName; }; |
| JitSummaryResolver.prototype.resolveSummary = function (reference) { |
| return this._summaries.get(reference) || null; |
| }; |
| JitSummaryResolver.prototype.getSymbolsOf = function () { return []; }; |
| JitSummaryResolver.prototype.getImportAs = function (reference) { return reference; }; |
| JitSummaryResolver.prototype.getKnownModuleName = function (fileName) { return null; }; |
| JitSummaryResolver.prototype.addSummary = function (summary) { this._summaries.set(summary.symbol, summary); }; |
| return JitSummaryResolver; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| function interpretStatements(statements, reflector) { |
| var ctx = new _ExecutionContext(null, null, null, new Map()); |
| var visitor = new StatementInterpreter(reflector); |
| visitor.visitAllStatements(statements, ctx); |
| var result = {}; |
| ctx.exports.forEach(function (exportName) { result[exportName] = ctx.vars.get(exportName); }); |
| return result; |
| } |
| function _executeFunctionStatements(varNames, varValues, statements, ctx, visitor) { |
| var childCtx = ctx.createChildWihtLocalVars(); |
| for (var i = 0; i < varNames.length; i++) { |
| childCtx.vars.set(varNames[i], varValues[i]); |
| } |
| var result = visitor.visitAllStatements(statements, childCtx); |
| return result ? result.value : null; |
| } |
| var _ExecutionContext = /** @class */ (function () { |
| function _ExecutionContext(parent, instance, className, vars) { |
| this.parent = parent; |
| this.instance = instance; |
| this.className = className; |
| this.vars = vars; |
| this.exports = []; |
| } |
| _ExecutionContext.prototype.createChildWihtLocalVars = function () { |
| return new _ExecutionContext(this, this.instance, this.className, new Map()); |
| }; |
| return _ExecutionContext; |
| }()); |
| var ReturnValue = /** @class */ (function () { |
| function ReturnValue(value) { |
| this.value = value; |
| } |
| return ReturnValue; |
| }()); |
| function createDynamicClass(_classStmt, _ctx, _visitor) { |
| var propertyDescriptors = {}; |
| _classStmt.getters.forEach(function (getter) { |
| // Note: use `function` instead of arrow function to capture `this` |
| propertyDescriptors[getter.name] = { |
| configurable: false, |
| get: function () { |
| var instanceCtx = new _ExecutionContext(_ctx, this, _classStmt.name, _ctx.vars); |
| return _executeFunctionStatements([], [], getter.body, instanceCtx, _visitor); |
| } |
| }; |
| }); |
| _classStmt.methods.forEach(function (method) { |
| var paramNames = method.params.map(function (param) { return param.name; }); |
| // Note: use `function` instead of arrow function to capture `this` |
| propertyDescriptors[method.name] = { |
| writable: false, |
| configurable: false, |
| value: function () { |
| var args = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| args[_i] = arguments[_i]; |
| } |
| var instanceCtx = new _ExecutionContext(_ctx, this, _classStmt.name, _ctx.vars); |
| return _executeFunctionStatements(paramNames, args, method.body, instanceCtx, _visitor); |
| } |
| }; |
| }); |
| var ctorParamNames = _classStmt.constructorMethod.params.map(function (param) { return param.name; }); |
| // Note: use `function` instead of arrow function to capture `this` |
| var ctor = function () { |
| var _this = this; |
| var args = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| args[_i] = arguments[_i]; |
| } |
| var instanceCtx = new _ExecutionContext(_ctx, this, _classStmt.name, _ctx.vars); |
| _classStmt.fields.forEach(function (field) { _this[field.name] = undefined; }); |
| _executeFunctionStatements(ctorParamNames, args, _classStmt.constructorMethod.body, instanceCtx, _visitor); |
| }; |
| var superClass = _classStmt.parent ? _classStmt.parent.visitExpression(_visitor, _ctx) : Object; |
| ctor.prototype = Object.create(superClass.prototype, propertyDescriptors); |
| return ctor; |
| } |
| var StatementInterpreter = /** @class */ (function () { |
| function StatementInterpreter(reflector) { |
| this.reflector = reflector; |
| } |
| StatementInterpreter.prototype.debugAst = function (ast) { return debugOutputAstAsTypeScript(ast); }; |
| StatementInterpreter.prototype.visitDeclareVarStmt = function (stmt, ctx) { |
| var initialValue = stmt.value ? stmt.value.visitExpression(this, ctx) : undefined; |
| ctx.vars.set(stmt.name, initialValue); |
| if (stmt.hasModifier(exports.StmtModifier.Exported)) { |
| ctx.exports.push(stmt.name); |
| } |
| return null; |
| }; |
| StatementInterpreter.prototype.visitWriteVarExpr = function (expr, ctx) { |
| var value = expr.value.visitExpression(this, ctx); |
| var currCtx = ctx; |
| while (currCtx != null) { |
| if (currCtx.vars.has(expr.name)) { |
| currCtx.vars.set(expr.name, value); |
| return value; |
| } |
| currCtx = currCtx.parent; |
| } |
| throw new Error("Not declared variable " + expr.name); |
| }; |
| StatementInterpreter.prototype.visitWrappedNodeExpr = function (ast, ctx) { |
| throw new Error('Cannot interpret a WrappedNodeExpr.'); |
| }; |
| StatementInterpreter.prototype.visitTypeofExpr = function (ast, ctx) { |
| throw new Error('Cannot interpret a TypeofExpr'); |
| }; |
| StatementInterpreter.prototype.visitReadVarExpr = function (ast, ctx) { |
| var varName = ast.name; |
| if (ast.builtin != null) { |
| switch (ast.builtin) { |
| case exports.BuiltinVar.Super: |
| return ctx.instance.__proto__; |
| case exports.BuiltinVar.This: |
| return ctx.instance; |
| case exports.BuiltinVar.CatchError: |
| varName = CATCH_ERROR_VAR$2; |
| break; |
| case exports.BuiltinVar.CatchStack: |
| varName = CATCH_STACK_VAR$2; |
| break; |
| default: |
| throw new Error("Unknown builtin variable " + ast.builtin); |
| } |
| } |
| var currCtx = ctx; |
| while (currCtx != null) { |
| if (currCtx.vars.has(varName)) { |
| return currCtx.vars.get(varName); |
| } |
| currCtx = currCtx.parent; |
| } |
| throw new Error("Not declared variable " + varName); |
| }; |
| StatementInterpreter.prototype.visitWriteKeyExpr = function (expr, ctx) { |
| var receiver = expr.receiver.visitExpression(this, ctx); |
| var index = expr.index.visitExpression(this, ctx); |
| var value = expr.value.visitExpression(this, ctx); |
| receiver[index] = value; |
| return value; |
| }; |
| StatementInterpreter.prototype.visitWritePropExpr = function (expr, ctx) { |
| var receiver = expr.receiver.visitExpression(this, ctx); |
| var value = expr.value.visitExpression(this, ctx); |
| receiver[expr.name] = value; |
| return value; |
| }; |
| StatementInterpreter.prototype.visitInvokeMethodExpr = function (expr, ctx) { |
| var receiver = expr.receiver.visitExpression(this, ctx); |
| var args = this.visitAllExpressions(expr.args, ctx); |
| var result; |
| if (expr.builtin != null) { |
| switch (expr.builtin) { |
| case exports.BuiltinMethod.ConcatArray: |
| result = receiver.concat.apply(receiver, __spread(args)); |
| break; |
| case exports.BuiltinMethod.SubscribeObservable: |
| result = receiver.subscribe({ next: args[0] }); |
| break; |
| case exports.BuiltinMethod.Bind: |
| result = receiver.bind.apply(receiver, __spread(args)); |
| break; |
| default: |
| throw new Error("Unknown builtin method " + expr.builtin); |
| } |
| } |
| else { |
| result = receiver[expr.name].apply(receiver, args); |
| } |
| return result; |
| }; |
| StatementInterpreter.prototype.visitInvokeFunctionExpr = function (stmt, ctx) { |
| var args = this.visitAllExpressions(stmt.args, ctx); |
| var fnExpr = stmt.fn; |
| if (fnExpr instanceof ReadVarExpr && fnExpr.builtin === exports.BuiltinVar.Super) { |
| ctx.instance.constructor.prototype.constructor.apply(ctx.instance, args); |
| return null; |
| } |
| else { |
| var fn = stmt.fn.visitExpression(this, ctx); |
| return fn.apply(null, args); |
| } |
| }; |
| StatementInterpreter.prototype.visitReturnStmt = function (stmt, ctx) { |
| return new ReturnValue(stmt.value.visitExpression(this, ctx)); |
| }; |
| StatementInterpreter.prototype.visitDeclareClassStmt = function (stmt, ctx) { |
| var clazz = createDynamicClass(stmt, ctx, this); |
| ctx.vars.set(stmt.name, clazz); |
| if (stmt.hasModifier(exports.StmtModifier.Exported)) { |
| ctx.exports.push(stmt.name); |
| } |
| return null; |
| }; |
| StatementInterpreter.prototype.visitExpressionStmt = function (stmt, ctx) { |
| return stmt.expr.visitExpression(this, ctx); |
| }; |
| StatementInterpreter.prototype.visitIfStmt = function (stmt, ctx) { |
| var condition = stmt.condition.visitExpression(this, ctx); |
| if (condition) { |
| return this.visitAllStatements(stmt.trueCase, ctx); |
| } |
| else if (stmt.falseCase != null) { |
| return this.visitAllStatements(stmt.falseCase, ctx); |
| } |
| return null; |
| }; |
| StatementInterpreter.prototype.visitTryCatchStmt = function (stmt, ctx) { |
| try { |
| return this.visitAllStatements(stmt.bodyStmts, ctx); |
| } |
| catch (e) { |
| var childCtx = ctx.createChildWihtLocalVars(); |
| childCtx.vars.set(CATCH_ERROR_VAR$2, e); |
| childCtx.vars.set(CATCH_STACK_VAR$2, e.stack); |
| return this.visitAllStatements(stmt.catchStmts, childCtx); |
| } |
| }; |
| StatementInterpreter.prototype.visitThrowStmt = function (stmt, ctx) { |
| throw stmt.error.visitExpression(this, ctx); |
| }; |
| StatementInterpreter.prototype.visitCommentStmt = function (stmt, context) { return null; }; |
| StatementInterpreter.prototype.visitJSDocCommentStmt = function (stmt, context) { return null; }; |
| StatementInterpreter.prototype.visitInstantiateExpr = function (ast, ctx) { |
| var args = this.visitAllExpressions(ast.args, ctx); |
| var clazz = ast.classExpr.visitExpression(this, ctx); |
| return new (clazz.bind.apply(clazz, __spread([void 0], args)))(); |
| }; |
| StatementInterpreter.prototype.visitLiteralExpr = function (ast, ctx) { return ast.value; }; |
| StatementInterpreter.prototype.visitExternalExpr = function (ast, ctx) { |
| return this.reflector.resolveExternalReference(ast.value); |
| }; |
| StatementInterpreter.prototype.visitConditionalExpr = function (ast, ctx) { |
| if (ast.condition.visitExpression(this, ctx)) { |
| return ast.trueCase.visitExpression(this, ctx); |
| } |
| else if (ast.falseCase != null) { |
| return ast.falseCase.visitExpression(this, ctx); |
| } |
| return null; |
| }; |
| StatementInterpreter.prototype.visitNotExpr = function (ast, ctx) { |
| return !ast.condition.visitExpression(this, ctx); |
| }; |
| StatementInterpreter.prototype.visitAssertNotNullExpr = function (ast, ctx) { |
| return ast.condition.visitExpression(this, ctx); |
| }; |
| StatementInterpreter.prototype.visitCastExpr = function (ast, ctx) { |
| return ast.value.visitExpression(this, ctx); |
| }; |
| StatementInterpreter.prototype.visitFunctionExpr = function (ast, ctx) { |
| var paramNames = ast.params.map(function (param) { return param.name; }); |
| return _declareFn(paramNames, ast.statements, ctx, this); |
| }; |
| StatementInterpreter.prototype.visitDeclareFunctionStmt = function (stmt, ctx) { |
| var paramNames = stmt.params.map(function (param) { return param.name; }); |
| ctx.vars.set(stmt.name, _declareFn(paramNames, stmt.statements, ctx, this)); |
| if (stmt.hasModifier(exports.StmtModifier.Exported)) { |
| ctx.exports.push(stmt.name); |
| } |
| return null; |
| }; |
| StatementInterpreter.prototype.visitBinaryOperatorExpr = function (ast, ctx) { |
| var _this = this; |
| var lhs = function () { return ast.lhs.visitExpression(_this, ctx); }; |
| var rhs = function () { return ast.rhs.visitExpression(_this, ctx); }; |
| switch (ast.operator) { |
| case exports.BinaryOperator.Equals: |
| return lhs() == rhs(); |
| case exports.BinaryOperator.Identical: |
| return lhs() === rhs(); |
| case exports.BinaryOperator.NotEquals: |
| return lhs() != rhs(); |
| case exports.BinaryOperator.NotIdentical: |
| return lhs() !== rhs(); |
| case exports.BinaryOperator.And: |
| return lhs() && rhs(); |
| case exports.BinaryOperator.Or: |
| return lhs() || rhs(); |
| case exports.BinaryOperator.Plus: |
| return lhs() + rhs(); |
| case exports.BinaryOperator.Minus: |
| return lhs() - rhs(); |
| case exports.BinaryOperator.Divide: |
| return lhs() / rhs(); |
| case exports.BinaryOperator.Multiply: |
| return lhs() * rhs(); |
| case exports.BinaryOperator.Modulo: |
| return lhs() % rhs(); |
| case exports.BinaryOperator.Lower: |
| return lhs() < rhs(); |
| case exports.BinaryOperator.LowerEquals: |
| return lhs() <= rhs(); |
| case exports.BinaryOperator.Bigger: |
| return lhs() > rhs(); |
| case exports.BinaryOperator.BiggerEquals: |
| return lhs() >= rhs(); |
| default: |
| throw new Error("Unknown operator " + ast.operator); |
| } |
| }; |
| StatementInterpreter.prototype.visitReadPropExpr = function (ast, ctx) { |
| var result; |
| var receiver = ast.receiver.visitExpression(this, ctx); |
| result = receiver[ast.name]; |
| return result; |
| }; |
| StatementInterpreter.prototype.visitReadKeyExpr = function (ast, ctx) { |
| var receiver = ast.receiver.visitExpression(this, ctx); |
| var prop = ast.index.visitExpression(this, ctx); |
| return receiver[prop]; |
| }; |
| StatementInterpreter.prototype.visitLiteralArrayExpr = function (ast, ctx) { |
| return this.visitAllExpressions(ast.entries, ctx); |
| }; |
| StatementInterpreter.prototype.visitLiteralMapExpr = function (ast, ctx) { |
| var _this = this; |
| var result = {}; |
| ast.entries.forEach(function (entry) { return result[entry.key] = entry.value.visitExpression(_this, ctx); }); |
| return result; |
| }; |
| StatementInterpreter.prototype.visitCommaExpr = function (ast, context) { |
| var values = this.visitAllExpressions(ast.parts, context); |
| return values[values.length - 1]; |
| }; |
| StatementInterpreter.prototype.visitAllExpressions = function (expressions, ctx) { |
| var _this = this; |
| return expressions.map(function (expr) { return expr.visitExpression(_this, ctx); }); |
| }; |
| StatementInterpreter.prototype.visitAllStatements = function (statements, ctx) { |
| for (var i = 0; i < statements.length; i++) { |
| var stmt = statements[i]; |
| var val = stmt.visitStatement(this, ctx); |
| if (val instanceof ReturnValue) { |
| return val; |
| } |
| } |
| return null; |
| }; |
| return StatementInterpreter; |
| }()); |
| function _declareFn(varNames, statements, ctx, visitor) { |
| return function () { |
| var args = []; |
| for (var _i = 0; _i < arguments.length; _i++) { |
| args[_i] = arguments[_i]; |
| } |
| return _executeFunctionStatements(varNames, args, statements, ctx, visitor); |
| }; |
| } |
| var CATCH_ERROR_VAR$2 = 'error'; |
| var CATCH_STACK_VAR$2 = 'stack'; |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * An internal module of the Angular compiler that begins with component types, |
| * extracts templates, and eventually produces a compiled version of the component |
| * ready for linking into an application. |
| * |
| * @security When compiling templates at runtime, you must ensure that the entire template comes |
| * from a trusted source. Attacker-controlled data introduced by a template could expose your |
| * application to XSS risks. For more detail, see the [Security Guide](http://g.co/ng/security). |
| */ |
| var JitCompiler = /** @class */ (function () { |
| function JitCompiler(_metadataResolver, _templateParser, _styleCompiler, _viewCompiler, _ngModuleCompiler, _summaryResolver, _reflector, _jitEvaluator, _compilerConfig, _console, getExtraNgModuleProviders) { |
| this._metadataResolver = _metadataResolver; |
| this._templateParser = _templateParser; |
| this._styleCompiler = _styleCompiler; |
| this._viewCompiler = _viewCompiler; |
| this._ngModuleCompiler = _ngModuleCompiler; |
| this._summaryResolver = _summaryResolver; |
| this._reflector = _reflector; |
| this._jitEvaluator = _jitEvaluator; |
| this._compilerConfig = _compilerConfig; |
| this._console = _console; |
| this.getExtraNgModuleProviders = getExtraNgModuleProviders; |
| this._compiledTemplateCache = new Map(); |
| this._compiledHostTemplateCache = new Map(); |
| this._compiledDirectiveWrapperCache = new Map(); |
| this._compiledNgModuleCache = new Map(); |
| this._sharedStylesheetCount = 0; |
| this._addedAotSummaries = new Set(); |
| } |
| JitCompiler.prototype.compileModuleSync = function (moduleType) { |
| return SyncAsync.assertSync(this._compileModuleAndComponents(moduleType, true)); |
| }; |
| JitCompiler.prototype.compileModuleAsync = function (moduleType) { |
| return Promise.resolve(this._compileModuleAndComponents(moduleType, false)); |
| }; |
| JitCompiler.prototype.compileModuleAndAllComponentsSync = function (moduleType) { |
| return SyncAsync.assertSync(this._compileModuleAndAllComponents(moduleType, true)); |
| }; |
| JitCompiler.prototype.compileModuleAndAllComponentsAsync = function (moduleType) { |
| return Promise.resolve(this._compileModuleAndAllComponents(moduleType, false)); |
| }; |
| JitCompiler.prototype.getComponentFactory = function (component) { |
| var summary = this._metadataResolver.getDirectiveSummary(component); |
| return summary.componentFactory; |
| }; |
| JitCompiler.prototype.loadAotSummaries = function (summaries) { |
| this.clearCache(); |
| this._addAotSummaries(summaries); |
| }; |
| JitCompiler.prototype._addAotSummaries = function (fn) { |
| if (this._addedAotSummaries.has(fn)) { |
| return; |
| } |
| this._addedAotSummaries.add(fn); |
| var summaries = fn(); |
| for (var i = 0; i < summaries.length; i++) { |
| var entry = summaries[i]; |
| if (typeof entry === 'function') { |
| this._addAotSummaries(entry); |
| } |
| else { |
| var summary = entry; |
| this._summaryResolver.addSummary({ symbol: summary.type.reference, metadata: null, type: summary }); |
| } |
| } |
| }; |
| JitCompiler.prototype.hasAotSummary = function (ref) { return !!this._summaryResolver.resolveSummary(ref); }; |
| JitCompiler.prototype._filterJitIdentifiers = function (ids) { |
| var _this = this; |
| return ids.map(function (mod) { return mod.reference; }).filter(function (ref) { return !_this.hasAotSummary(ref); }); |
| }; |
| JitCompiler.prototype._compileModuleAndComponents = function (moduleType, isSync) { |
| var _this = this; |
| return SyncAsync.then(this._loadModules(moduleType, isSync), function () { |
| _this._compileComponents(moduleType, null); |
| return _this._compileModule(moduleType); |
| }); |
| }; |
| JitCompiler.prototype._compileModuleAndAllComponents = function (moduleType, isSync) { |
| var _this = this; |
| return SyncAsync.then(this._loadModules(moduleType, isSync), function () { |
| var componentFactories = []; |
| _this._compileComponents(moduleType, componentFactories); |
| return { |
| ngModuleFactory: _this._compileModule(moduleType), |
| componentFactories: componentFactories |
| }; |
| }); |
| }; |
| JitCompiler.prototype._loadModules = function (mainModule, isSync) { |
| var _this = this; |
| var loading = []; |
| var mainNgModule = this._metadataResolver.getNgModuleMetadata(mainModule); |
| // Note: for runtime compilation, we want to transitively compile all modules, |
| // so we also need to load the declared directives / pipes for all nested modules. |
| this._filterJitIdentifiers(mainNgModule.transitiveModule.modules).forEach(function (nestedNgModule) { |
| // getNgModuleMetadata only returns null if the value passed in is not an NgModule |
| var moduleMeta = _this._metadataResolver.getNgModuleMetadata(nestedNgModule); |
| _this._filterJitIdentifiers(moduleMeta.declaredDirectives).forEach(function (ref) { |
| var promise = _this._metadataResolver.loadDirectiveMetadata(moduleMeta.type.reference, ref, isSync); |
| if (promise) { |
| loading.push(promise); |
| } |
| }); |
| _this._filterJitIdentifiers(moduleMeta.declaredPipes) |
| .forEach(function (ref) { return _this._metadataResolver.getOrLoadPipeMetadata(ref); }); |
| }); |
| return SyncAsync.all(loading); |
| }; |
| JitCompiler.prototype._compileModule = function (moduleType) { |
| var ngModuleFactory = this._compiledNgModuleCache.get(moduleType); |
| if (!ngModuleFactory) { |
| var moduleMeta = this._metadataResolver.getNgModuleMetadata(moduleType); |
| // Always provide a bound Compiler |
| var extraProviders = this.getExtraNgModuleProviders(moduleMeta.type.reference); |
| var outputCtx = createOutputContext(); |
| var compileResult = this._ngModuleCompiler.compile(outputCtx, moduleMeta, extraProviders); |
| ngModuleFactory = this._interpretOrJit(ngModuleJitUrl(moduleMeta), outputCtx.statements)[compileResult.ngModuleFactoryVar]; |
| this._compiledNgModuleCache.set(moduleMeta.type.reference, ngModuleFactory); |
| } |
| return ngModuleFactory; |
| }; |
| /** |
| * @internal |
| */ |
| JitCompiler.prototype._compileComponents = function (mainModule, allComponentFactories) { |
| var _this = this; |
| var ngModule = this._metadataResolver.getNgModuleMetadata(mainModule); |
| var moduleByJitDirective = new Map(); |
| var templates = new Set(); |
| var transJitModules = this._filterJitIdentifiers(ngModule.transitiveModule.modules); |
| transJitModules.forEach(function (localMod) { |
| var localModuleMeta = _this._metadataResolver.getNgModuleMetadata(localMod); |
| _this._filterJitIdentifiers(localModuleMeta.declaredDirectives).forEach(function (dirRef) { |
| moduleByJitDirective.set(dirRef, localModuleMeta); |
| var dirMeta = _this._metadataResolver.getDirectiveMetadata(dirRef); |
| if (dirMeta.isComponent) { |
| templates.add(_this._createCompiledTemplate(dirMeta, localModuleMeta)); |
| if (allComponentFactories) { |
| var template = _this._createCompiledHostTemplate(dirMeta.type.reference, localModuleMeta); |
| templates.add(template); |
| allComponentFactories.push(dirMeta.componentFactory); |
| } |
| } |
| }); |
| }); |
| transJitModules.forEach(function (localMod) { |
| var localModuleMeta = _this._metadataResolver.getNgModuleMetadata(localMod); |
| _this._filterJitIdentifiers(localModuleMeta.declaredDirectives).forEach(function (dirRef) { |
| var dirMeta = _this._metadataResolver.getDirectiveMetadata(dirRef); |
| if (dirMeta.isComponent) { |
| dirMeta.entryComponents.forEach(function (entryComponentType) { |
| var moduleMeta = moduleByJitDirective.get(entryComponentType.componentType); |
| templates.add(_this._createCompiledHostTemplate(entryComponentType.componentType, moduleMeta)); |
| }); |
| } |
| }); |
| localModuleMeta.entryComponents.forEach(function (entryComponentType) { |
| if (!_this.hasAotSummary(entryComponentType.componentType)) { |
| var moduleMeta = moduleByJitDirective.get(entryComponentType.componentType); |
| templates.add(_this._createCompiledHostTemplate(entryComponentType.componentType, moduleMeta)); |
| } |
| }); |
| }); |
| templates.forEach(function (template) { return _this._compileTemplate(template); }); |
| }; |
| JitCompiler.prototype.clearCacheFor = function (type) { |
| this._compiledNgModuleCache.delete(type); |
| this._metadataResolver.clearCacheFor(type); |
| this._compiledHostTemplateCache.delete(type); |
| var compiledTemplate = this._compiledTemplateCache.get(type); |
| if (compiledTemplate) { |
| this._compiledTemplateCache.delete(type); |
| } |
| }; |
| JitCompiler.prototype.clearCache = function () { |
| // Note: don't clear the _addedAotSummaries, as they don't change! |
| this._metadataResolver.clearCache(); |
| this._compiledTemplateCache.clear(); |
| this._compiledHostTemplateCache.clear(); |
| this._compiledNgModuleCache.clear(); |
| }; |
| JitCompiler.prototype._createCompiledHostTemplate = function (compType, ngModule) { |
| if (!ngModule) { |
| throw new Error("Component " + stringify(compType) + " is not part of any NgModule or the module has not been imported into your module."); |
| } |
| var compiledTemplate = this._compiledHostTemplateCache.get(compType); |
| if (!compiledTemplate) { |
| var compMeta = this._metadataResolver.getDirectiveMetadata(compType); |
| assertComponent(compMeta); |
| var hostMeta = this._metadataResolver.getHostComponentMetadata(compMeta, compMeta.componentFactory.viewDefFactory); |
| compiledTemplate = |
| new CompiledTemplate(true, compMeta.type, hostMeta, ngModule, [compMeta.type]); |
| this._compiledHostTemplateCache.set(compType, compiledTemplate); |
| } |
| return compiledTemplate; |
| }; |
| JitCompiler.prototype._createCompiledTemplate = function (compMeta, ngModule) { |
| var compiledTemplate = this._compiledTemplateCache.get(compMeta.type.reference); |
| if (!compiledTemplate) { |
| assertComponent(compMeta); |
| compiledTemplate = new CompiledTemplate(false, compMeta.type, compMeta, ngModule, ngModule.transitiveModule.directives); |
| this._compiledTemplateCache.set(compMeta.type.reference, compiledTemplate); |
| } |
| return compiledTemplate; |
| }; |
| JitCompiler.prototype._compileTemplate = function (template) { |
| var _this = this; |
| if (template.isCompiled) { |
| return; |
| } |
| var compMeta = template.compMeta; |
| var externalStylesheetsByModuleUrl = new Map(); |
| var outputContext = createOutputContext(); |
| var componentStylesheet = this._styleCompiler.compileComponent(outputContext, compMeta); |
| compMeta.template.externalStylesheets.forEach(function (stylesheetMeta) { |
| var compiledStylesheet = _this._styleCompiler.compileStyles(createOutputContext(), compMeta, stylesheetMeta); |
| externalStylesheetsByModuleUrl.set(stylesheetMeta.moduleUrl, compiledStylesheet); |
| }); |
| this._resolveStylesCompileResult(componentStylesheet, externalStylesheetsByModuleUrl); |
| var pipes = template.ngModule.transitiveModule.pipes.map(function (pipe) { return _this._metadataResolver.getPipeSummary(pipe.reference); }); |
| var _a = this._parseTemplate(compMeta, template.ngModule, template.directives), parsedTemplate = _a.template, usedPipes = _a.pipes; |
| var compileResult = this._viewCompiler.compileComponent(outputContext, compMeta, parsedTemplate, variable(componentStylesheet.stylesVar), usedPipes); |
| var evalResult = this._interpretOrJit(templateJitUrl(template.ngModule.type, template.compMeta), outputContext.statements); |
| var viewClass = evalResult[compileResult.viewClassVar]; |
| var rendererType = evalResult[compileResult.rendererTypeVar]; |
| template.compiled(viewClass, rendererType); |
| }; |
| JitCompiler.prototype._parseTemplate = function (compMeta, ngModule, directiveIdentifiers) { |
| var _this = this; |
| // Note: ! is ok here as components always have a template. |
| var preserveWhitespaces = compMeta.template.preserveWhitespaces; |
| var directives = directiveIdentifiers.map(function (dir) { return _this._metadataResolver.getDirectiveSummary(dir.reference); }); |
| var pipes = ngModule.transitiveModule.pipes.map(function (pipe) { return _this._metadataResolver.getPipeSummary(pipe.reference); }); |
| return this._templateParser.parse(compMeta, compMeta.template.htmlAst, directives, pipes, ngModule.schemas, templateSourceUrl(ngModule.type, compMeta, compMeta.template), preserveWhitespaces); |
| }; |
| JitCompiler.prototype._resolveStylesCompileResult = function (result, externalStylesheetsByModuleUrl) { |
| var _this = this; |
| result.dependencies.forEach(function (dep, i) { |
| var nestedCompileResult = externalStylesheetsByModuleUrl.get(dep.moduleUrl); |
| var nestedStylesArr = _this._resolveAndEvalStylesCompileResult(nestedCompileResult, externalStylesheetsByModuleUrl); |
| dep.setValue(nestedStylesArr); |
| }); |
| }; |
| JitCompiler.prototype._resolveAndEvalStylesCompileResult = function (result, externalStylesheetsByModuleUrl) { |
| this._resolveStylesCompileResult(result, externalStylesheetsByModuleUrl); |
| return this._interpretOrJit(sharedStylesheetJitUrl(result.meta, this._sharedStylesheetCount++), result.outputCtx.statements)[result.stylesVar]; |
| }; |
| JitCompiler.prototype._interpretOrJit = function (sourceUrl, statements) { |
| if (!this._compilerConfig.useJit) { |
| return interpretStatements(statements, this._reflector); |
| } |
| else { |
| return this._jitEvaluator.evaluateStatements(sourceUrl, statements, this._reflector, this._compilerConfig.jitDevMode); |
| } |
| }; |
| return JitCompiler; |
| }()); |
| var CompiledTemplate = /** @class */ (function () { |
| function CompiledTemplate(isHost, compType, compMeta, ngModule, directives) { |
| this.isHost = isHost; |
| this.compType = compType; |
| this.compMeta = compMeta; |
| this.ngModule = ngModule; |
| this.directives = directives; |
| this._viewClass = null; |
| this.isCompiled = false; |
| } |
| CompiledTemplate.prototype.compiled = function (viewClass, rendererType) { |
| this._viewClass = viewClass; |
| this.compMeta.componentViewType.setDelegate(viewClass); |
| for (var prop in rendererType) { |
| this.compMeta.rendererType[prop] = rendererType[prop]; |
| } |
| this.isCompiled = true; |
| }; |
| return CompiledTemplate; |
| }()); |
| function assertComponent(meta) { |
| if (!meta.isComponent) { |
| throw new Error("Could not compile '" + identifierName(meta.type) + "' because it is not a component."); |
| } |
| } |
| function createOutputContext() { |
| var importExpr$1 = function (symbol) { |
| return importExpr({ name: identifierName(symbol), moduleName: null, runtime: symbol }); |
| }; |
| return { statements: [], genFilePath: '', importExpr: importExpr$1, constantPool: new ConstantPool() }; |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * Provides access to reflection data about symbols that the compiler needs. |
| */ |
| var CompileReflector = /** @class */ (function () { |
| function CompileReflector() { |
| } |
| return CompileReflector; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * Create a {@link UrlResolver} with no package prefix. |
| */ |
| function createUrlResolverWithoutPackagePrefix() { |
| return new UrlResolver(); |
| } |
| function createOfflineCompileUrlResolver() { |
| return new UrlResolver('.'); |
| } |
| var UrlResolver = /** @class */ (function () { |
| function UrlResolverImpl(_packagePrefix) { |
| if (_packagePrefix === void 0) { _packagePrefix = null; } |
| this._packagePrefix = _packagePrefix; |
| } |
| /** |
| * Resolves the `url` given the `baseUrl`: |
| * - when the `url` is null, the `baseUrl` is returned, |
| * - if `url` is relative ('path/to/here', './path/to/here'), the resolved url is a combination of |
| * `baseUrl` and `url`, |
| * - if `url` is absolute (it has a scheme: 'http://', 'https://' or start with '/'), the `url` is |
| * returned as is (ignoring the `baseUrl`) |
| */ |
| UrlResolverImpl.prototype.resolve = function (baseUrl, url) { |
| var resolvedUrl = url; |
| if (baseUrl != null && baseUrl.length > 0) { |
| resolvedUrl = _resolveUrl(baseUrl, resolvedUrl); |
| } |
| var resolvedParts = _split(resolvedUrl); |
| var prefix = this._packagePrefix; |
| if (prefix != null && resolvedParts != null && |
| resolvedParts[_ComponentIndex.Scheme] == 'package') { |
| var path = resolvedParts[_ComponentIndex.Path]; |
| prefix = prefix.replace(/\/+$/, ''); |
| path = path.replace(/^\/+/, ''); |
| return prefix + "/" + path; |
| } |
| return resolvedUrl; |
| }; |
| return UrlResolverImpl; |
| }()); |
| /** |
| * Extract the scheme of a URL. |
| */ |
| function getUrlScheme(url) { |
| var match = _split(url); |
| return (match && match[_ComponentIndex.Scheme]) || ''; |
| } |
| // The code below is adapted from Traceur: |
| // https://github.com/google/traceur-compiler/blob/9511c1dafa972bf0de1202a8a863bad02f0f95a8/src/runtime/url.js |
| /** |
| * Builds a URI string from already-encoded parts. |
| * |
| * No encoding is performed. Any component may be omitted as either null or |
| * undefined. |
| * |
| * @param opt_scheme The scheme such as 'http'. |
| * @param opt_userInfo The user name before the '@'. |
| * @param opt_domain The domain such as 'www.google.com', already |
| * URI-encoded. |
| * @param opt_port The port number. |
| * @param opt_path The path, already URI-encoded. If it is not |
| * empty, it must begin with a slash. |
| * @param opt_queryData The URI-encoded query data. |
| * @param opt_fragment The URI-encoded fragment identifier. |
| * @return The fully combined URI. |
| */ |
| function _buildFromEncodedParts(opt_scheme, opt_userInfo, opt_domain, opt_port, opt_path, opt_queryData, opt_fragment) { |
| var out = []; |
| if (opt_scheme != null) { |
| out.push(opt_scheme + ':'); |
| } |
| if (opt_domain != null) { |
| out.push('//'); |
| if (opt_userInfo != null) { |
| out.push(opt_userInfo + '@'); |
| } |
| out.push(opt_domain); |
| if (opt_port != null) { |
| out.push(':' + opt_port); |
| } |
| } |
| if (opt_path != null) { |
| out.push(opt_path); |
| } |
| if (opt_queryData != null) { |
| out.push('?' + opt_queryData); |
| } |
| if (opt_fragment != null) { |
| out.push('#' + opt_fragment); |
| } |
| return out.join(''); |
| } |
| /** |
| * A regular expression for breaking a URI into its component parts. |
| * |
| * {@link http://www.gbiv.com/protocols/uri/rfc/rfc3986.html#RFC2234} says |
| * As the "first-match-wins" algorithm is identical to the "greedy" |
| * disambiguation method used by POSIX regular expressions, it is natural and |
| * commonplace to use a regular expression for parsing the potential five |
| * components of a URI reference. |
| * |
| * The following line is the regular expression for breaking-down a |
| * well-formed URI reference into its components. |
| * |
| * <pre> |
| * ^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))? |
| * 12 3 4 5 6 7 8 9 |
| * </pre> |
| * |
| * The numbers in the second line above are only to assist readability; they |
| * indicate the reference points for each subexpression (i.e., each paired |
| * parenthesis). We refer to the value matched for subexpression <n> as $<n>. |
| * For example, matching the above expression to |
| * <pre> |
| * http://www.ics.uci.edu/pub/ietf/uri/#Related |
| * </pre> |
| * results in the following subexpression matches: |
| * <pre> |
| * $1 = http: |
| * $2 = http |
| * $3 = //www.ics.uci.edu |
| * $4 = www.ics.uci.edu |
| * $5 = /pub/ietf/uri/ |
| * $6 = <undefined> |
| * $7 = <undefined> |
| * $8 = #Related |
| * $9 = Related |
| * </pre> |
| * where <undefined> indicates that the component is not present, as is the |
| * case for the query component in the above example. Therefore, we can |
| * determine the value of the five components as |
| * <pre> |
| * scheme = $2 |
| * authority = $4 |
| * path = $5 |
| * query = $7 |
| * fragment = $9 |
| * </pre> |
| * |
| * The regular expression has been modified slightly to expose the |
| * userInfo, domain, and port separately from the authority. |
| * The modified version yields |
| * <pre> |
| * $1 = http scheme |
| * $2 = <undefined> userInfo -\ |
| * $3 = www.ics.uci.edu domain | authority |
| * $4 = <undefined> port -/ |
| * $5 = /pub/ietf/uri/ path |
| * $6 = <undefined> query without ? |
| * $7 = Related fragment without # |
| * </pre> |
| * @internal |
| */ |
| var _splitRe = new RegExp('^' + |
| '(?:' + |
| '([^:/?#.]+)' + // scheme - ignore special characters |
| // used by other URL parts such as :, |
| // ?, /, #, and . |
| ':)?' + |
| '(?://' + |
| '(?:([^/?#]*)@)?' + // userInfo |
| '([\\w\\d\\-\\u0100-\\uffff.%]*)' + // domain - restrict to letters, |
| // digits, dashes, dots, percent |
| // escapes, and unicode characters. |
| '(?::([0-9]+))?' + // port |
| ')?' + |
| '([^?#]+)?' + // path |
| '(?:\\?([^#]*))?' + // query |
| '(?:#(.*))?' + // fragment |
| '$'); |
| /** |
| * The index of each URI component in the return value of goog.uri.utils.split. |
| * @enum {number} |
| */ |
| var _ComponentIndex; |
| (function (_ComponentIndex) { |
| _ComponentIndex[_ComponentIndex["Scheme"] = 1] = "Scheme"; |
| _ComponentIndex[_ComponentIndex["UserInfo"] = 2] = "UserInfo"; |
| _ComponentIndex[_ComponentIndex["Domain"] = 3] = "Domain"; |
| _ComponentIndex[_ComponentIndex["Port"] = 4] = "Port"; |
| _ComponentIndex[_ComponentIndex["Path"] = 5] = "Path"; |
| _ComponentIndex[_ComponentIndex["QueryData"] = 6] = "QueryData"; |
| _ComponentIndex[_ComponentIndex["Fragment"] = 7] = "Fragment"; |
| })(_ComponentIndex || (_ComponentIndex = {})); |
| /** |
| * Splits a URI into its component parts. |
| * |
| * Each component can be accessed via the component indices; for example: |
| * <pre> |
| * goog.uri.utils.split(someStr)[goog.uri.utils.CompontentIndex.QUERY_DATA]; |
| * </pre> |
| * |
| * @param uri The URI string to examine. |
| * @return Each component still URI-encoded. |
| * Each component that is present will contain the encoded value, whereas |
| * components that are not present will be undefined or empty, depending |
| * on the browser's regular expression implementation. Never null, since |
| * arbitrary strings may still look like path names. |
| */ |
| function _split(uri) { |
| return uri.match(_splitRe); |
| } |
| /** |
| * Removes dot segments in given path component, as described in |
| * RFC 3986, section 5.2.4. |
| * |
| * @param path A non-empty path component. |
| * @return Path component with removed dot segments. |
| */ |
| function _removeDotSegments(path) { |
| if (path == '/') |
| return '/'; |
| var leadingSlash = path[0] == '/' ? '/' : ''; |
| var trailingSlash = path[path.length - 1] === '/' ? '/' : ''; |
| var segments = path.split('/'); |
| var out = []; |
| var up = 0; |
| for (var pos = 0; pos < segments.length; pos++) { |
| var segment = segments[pos]; |
| switch (segment) { |
| case '': |
| case '.': |
| break; |
| case '..': |
| if (out.length > 0) { |
| out.pop(); |
| } |
| else { |
| up++; |
| } |
| break; |
| default: |
| out.push(segment); |
| } |
| } |
| if (leadingSlash == '') { |
| while (up-- > 0) { |
| out.unshift('..'); |
| } |
| if (out.length === 0) |
| out.push('.'); |
| } |
| return leadingSlash + out.join('/') + trailingSlash; |
| } |
| /** |
| * Takes an array of the parts from split and canonicalizes the path part |
| * and then joins all the parts. |
| */ |
| function _joinAndCanonicalizePath(parts) { |
| var path = parts[_ComponentIndex.Path]; |
| path = path == null ? '' : _removeDotSegments(path); |
| parts[_ComponentIndex.Path] = path; |
| return _buildFromEncodedParts(parts[_ComponentIndex.Scheme], parts[_ComponentIndex.UserInfo], parts[_ComponentIndex.Domain], parts[_ComponentIndex.Port], path, parts[_ComponentIndex.QueryData], parts[_ComponentIndex.Fragment]); |
| } |
| /** |
| * Resolves a URL. |
| * @param base The URL acting as the base URL. |
| * @param to The URL to resolve. |
| */ |
| function _resolveUrl(base, url) { |
| var parts = _split(encodeURI(url)); |
| var baseParts = _split(base); |
| if (parts[_ComponentIndex.Scheme] != null) { |
| return _joinAndCanonicalizePath(parts); |
| } |
| else { |
| parts[_ComponentIndex.Scheme] = baseParts[_ComponentIndex.Scheme]; |
| } |
| for (var i = _ComponentIndex.Scheme; i <= _ComponentIndex.Port; i++) { |
| if (parts[i] == null) { |
| parts[i] = baseParts[i]; |
| } |
| } |
| if (parts[_ComponentIndex.Path][0] == '/') { |
| return _joinAndCanonicalizePath(parts); |
| } |
| var path = baseParts[_ComponentIndex.Path]; |
| if (path == null) |
| path = '/'; |
| var index = path.lastIndexOf('/'); |
| path = path.substring(0, index + 1) + parts[_ComponentIndex.Path]; |
| parts[_ComponentIndex.Path] = path; |
| return _joinAndCanonicalizePath(parts); |
| } |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| var Extractor = /** @class */ (function () { |
| function Extractor(host, staticSymbolResolver, messageBundle, metadataResolver) { |
| this.host = host; |
| this.staticSymbolResolver = staticSymbolResolver; |
| this.messageBundle = messageBundle; |
| this.metadataResolver = metadataResolver; |
| } |
| Extractor.prototype.extract = function (rootFiles) { |
| var _this = this; |
| var _a = analyzeAndValidateNgModules(rootFiles, this.host, this.staticSymbolResolver, this.metadataResolver), files = _a.files, ngModules = _a.ngModules; |
| return Promise |
| .all(ngModules.map(function (ngModule) { return _this.metadataResolver.loadNgModuleDirectiveAndPipeMetadata(ngModule.type.reference, false); })) |
| .then(function () { |
| var errors = []; |
| files.forEach(function (file) { |
| var compMetas = []; |
| file.directives.forEach(function (directiveType) { |
| var dirMeta = _this.metadataResolver.getDirectiveMetadata(directiveType); |
| if (dirMeta && dirMeta.isComponent) { |
| compMetas.push(dirMeta); |
| } |
| }); |
| compMetas.forEach(function (compMeta) { |
| var html = compMeta.template.template; |
| // Template URL points to either an HTML or TS file depending on |
| // whether the file is used with `templateUrl:` or `template:`, |
| // respectively. |
| var templateUrl = compMeta.template.templateUrl; |
| var interpolationConfig = InterpolationConfig.fromArray(compMeta.template.interpolation); |
| errors.push.apply(errors, __spread(_this.messageBundle.updateFromTemplate(html, templateUrl, interpolationConfig))); |
| }); |
| }); |
| if (errors.length) { |
| throw new Error(errors.map(function (e) { return e.toString(); }).join('\n')); |
| } |
| return _this.messageBundle; |
| }); |
| }; |
| Extractor.create = function (host, locale) { |
| var htmlParser = new HtmlParser(); |
| var urlResolver = createAotUrlResolver(host); |
| var symbolCache = new StaticSymbolCache(); |
| var summaryResolver = new AotSummaryResolver(host, symbolCache); |
| var staticSymbolResolver = new StaticSymbolResolver(host, symbolCache, summaryResolver); |
| var staticReflector = new StaticReflector(summaryResolver, staticSymbolResolver); |
| var config = new CompilerConfig({ defaultEncapsulation: ViewEncapsulation.Emulated, useJit: false }); |
| var normalizer = new DirectiveNormalizer({ get: function (url) { return host.loadResource(url); } }, urlResolver, htmlParser, config); |
| var elementSchemaRegistry = new DomElementSchemaRegistry(); |
| var resolver = new CompileMetadataResolver(config, htmlParser, new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector), new PipeResolver(staticReflector), summaryResolver, elementSchemaRegistry, normalizer, console, symbolCache, staticReflector); |
| // TODO(vicb): implicit tags & attributes |
| var messageBundle = new MessageBundle(htmlParser, [], {}, locale); |
| var extractor = new Extractor(host, staticSymbolResolver, messageBundle, resolver); |
| return { extractor: extractor, staticReflector: staticReflector }; |
| }; |
| return Extractor; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| /** |
| * Processes `Target`s with a given set of directives and performs a binding operation, which |
| * returns an object similar to TypeScript's `ts.TypeChecker` that contains knowledge about the |
| * target. |
| */ |
| var R3TargetBinder = /** @class */ (function () { |
| function R3TargetBinder(directiveMatcher) { |
| this.directiveMatcher = directiveMatcher; |
| } |
| /** |
| * Perform a binding operation on the given `Target` and return a `BoundTarget` which contains |
| * metadata about the types referenced in the template. |
| */ |
| R3TargetBinder.prototype.bind = function (target) { |
| if (!target.template) { |
| // TODO(alxhub): handle targets which contain things like HostBindings, etc. |
| throw new Error('Binding without a template not yet supported'); |
| } |
| // First, parse the template into a `Scope` structure. This operation captures the syntactic |
| // scopes in the template and makes them available for later use. |
| var scope = Scope.apply(target.template); |
| // Next, perform directive matching on the template using the `DirectiveBinder`. This returns: |
| // - directives: Map of nodes (elements & ng-templates) to the directives on them. |
| // - bindings: Map of inputs, outputs, and attributes to the directive/element that claims |
| // them. TODO(alxhub): handle multiple directives claiming an input/output/etc. |
| // - references: Map of #references to their targets. |
| var _a = DirectiveBinder.apply(target.template, this.directiveMatcher), directives = _a.directives, bindings = _a.bindings, references = _a.references; |
| // Finally, run the TemplateBinder to bind references, variables, and other entities within the |
| // template. This extracts all the metadata that doesn't depend on directive matching. |
| var _b = TemplateBinder.apply(target.template, scope), expressions = _b.expressions, symbols = _b.symbols, nestingLevel = _b.nestingLevel, usedPipes = _b.usedPipes; |
| return new R3BoundTarget(target, directives, bindings, references, expressions, symbols, nestingLevel, usedPipes); |
| }; |
| return R3TargetBinder; |
| }()); |
| /** |
| * Represents a binding scope within a template. |
| * |
| * Any variables, references, or other named entities declared within the template will |
| * be captured and available by name in `namedEntities`. Additionally, child templates will |
| * be analyzed and have their child `Scope`s available in `childScopes`. |
| */ |
| var Scope = /** @class */ (function () { |
| function Scope(parentScope) { |
| this.parentScope = parentScope; |
| /** |
| * Named members of the `Scope`, such as `Reference`s or `Variable`s. |
| */ |
| this.namedEntities = new Map(); |
| /** |
| * Child `Scope`s for immediately nested `Template`s. |
| */ |
| this.childScopes = new Map(); |
| } |
| /** |
| * Process a template (either as a `Template` sub-template with variables, or a plain array of |
| * template `Node`s) and construct its `Scope`. |
| */ |
| Scope.apply = function (template) { |
| var scope = new Scope(); |
| scope.ingest(template); |
| return scope; |
| }; |
| /** |
| * Internal method to process the template and populate the `Scope`. |
| */ |
| Scope.prototype.ingest = function (template) { |
| var _this = this; |
| if (template instanceof Template) { |
| // Variables on an <ng-template> are defined in the inner scope. |
| template.variables.forEach(function (node) { return _this.visitVariable(node); }); |
| // Process the nodes of the template. |
| template.children.forEach(function (node) { return node.visit(_this); }); |
| } |
| else { |
| // No overarching `Template` instance, so process the nodes directly. |
| template.forEach(function (node) { return node.visit(_this); }); |
| } |
| }; |
| Scope.prototype.visitElement = function (element) { |
| var _this = this; |
| // `Element`s in the template may have `Reference`s which are captured in the scope. |
| element.references.forEach(function (node) { return _this.visitReference(node); }); |
| // Recurse into the `Element`'s children. |
| element.children.forEach(function (node) { return node.visit(_this); }); |
| }; |
| Scope.prototype.visitTemplate = function (template) { |
| var _this = this; |
| // References on a <ng-template> are defined in the outer scope, so capture them before |
| // processing the template's child scope. |
| template.references.forEach(function (node) { return _this.visitReference(node); }); |
| // Next, create an inner scope and process the template within it. |
| var scope = new Scope(this); |
| scope.ingest(template); |
| this.childScopes.set(template, scope); |
| }; |
| Scope.prototype.visitVariable = function (variable) { |
| // Declare the variable if it's not already. |
| this.maybeDeclare(variable); |
| }; |
| Scope.prototype.visitReference = function (reference) { |
| // Declare the variable if it's not already. |
| this.maybeDeclare(reference); |
| }; |
| // Unused visitors. |
| Scope.prototype.visitContent = function (content) { }; |
| Scope.prototype.visitBoundAttribute = function (attr) { }; |
| Scope.prototype.visitBoundEvent = function (event) { }; |
| Scope.prototype.visitBoundText = function (text) { }; |
| Scope.prototype.visitText = function (text) { }; |
| Scope.prototype.visitTextAttribute = function (attr) { }; |
| Scope.prototype.visitIcu = function (icu) { }; |
| Scope.prototype.maybeDeclare = function (thing) { |
| // Declare something with a name, as long as that name isn't taken. |
| if (!this.namedEntities.has(thing.name)) { |
| this.namedEntities.set(thing.name, thing); |
| } |
| }; |
| /** |
| * Look up a variable within this `Scope`. |
| * |
| * This can recurse into a parent `Scope` if it's available. |
| */ |
| Scope.prototype.lookup = function (name) { |
| if (this.namedEntities.has(name)) { |
| // Found in the local scope. |
| return this.namedEntities.get(name); |
| } |
| else if (this.parentScope !== undefined) { |
| // Not in the local scope, but there's a parent scope so check there. |
| return this.parentScope.lookup(name); |
| } |
| else { |
| // At the top level and it wasn't found. |
| return null; |
| } |
| }; |
| /** |
| * Get the child scope for a `Template`. |
| * |
| * This should always be defined. |
| */ |
| Scope.prototype.getChildScope = function (template) { |
| var res = this.childScopes.get(template); |
| if (res === undefined) { |
| throw new Error("Assertion error: child scope for " + template + " not found"); |
| } |
| return res; |
| }; |
| return Scope; |
| }()); |
| /** |
| * Processes a template and matches directives on nodes (elements and templates). |
| * |
| * Usually used via the static `apply()` method. |
| */ |
| var DirectiveBinder = /** @class */ (function () { |
| function DirectiveBinder(matcher, directives, bindings, references) { |
| this.matcher = matcher; |
| this.directives = directives; |
| this.bindings = bindings; |
| this.references = references; |
| } |
| /** |
| * Process a template (list of `Node`s) and perform directive matching against each node. |
| * |
| * @param template the list of template `Node`s to match (recursively). |
| * @param selectorMatcher a `SelectorMatcher` containing the directives that are in scope for |
| * this template. |
| * @returns three maps which contain information about directives in the template: the |
| * `directives` map which lists directives matched on each node, the `bindings` map which |
| * indicates which directives claimed which bindings (inputs, outputs, etc), and the `references` |
| * map which resolves #references (`Reference`s) within the template to the named directive or |
| * template node. |
| */ |
| DirectiveBinder.apply = function (template, selectorMatcher) { |
| var directives = new Map(); |
| var bindings = new Map(); |
| var references = new Map(); |
| var matcher = new DirectiveBinder(selectorMatcher, directives, bindings, references); |
| matcher.ingest(template); |
| return { directives: directives, bindings: bindings, references: references }; |
| }; |
| DirectiveBinder.prototype.ingest = function (template) { |
| var _this = this; |
| template.forEach(function (node) { return node.visit(_this); }); |
| }; |
| DirectiveBinder.prototype.visitElement = function (element) { this.visitElementOrTemplate(element.name, element); }; |
| DirectiveBinder.prototype.visitTemplate = function (template) { this.visitElementOrTemplate('ng-template', template); }; |
| DirectiveBinder.prototype.visitElementOrTemplate = function (tag, node) { |
| var _this = this; |
| // First, determine the HTML shape of the node for the purpose of directive matching. |
| // Do this by building up a `CssSelector` for the node. |
| var cssSelector = new CssSelector(); |
| cssSelector.setElement(tag); |
| // Add attributes to the CSS selector. |
| var attrs = getAttrsForDirectiveMatching(node); |
| Object.getOwnPropertyNames(attrs).forEach(function (name) { |
| var value = attrs[name]; |
| cssSelector.addAttribute(name, value); |
| // Treat the 'class' attribute specially. |
| if (name.toLowerCase() === 'class') { |
| var classes = value.trim().split(/\s+/g); |
| classes.forEach(function (className) { return cssSelector.addClassName(className); }); |
| } |
| }); |
| // Next, use the `SelectorMatcher` to get the list of directives on the node. |
| var directives = []; |
| this.matcher.match(cssSelector, function (_, directive) { return directives.push(directive); }); |
| if (directives.length > 0) { |
| this.directives.set(node, directives); |
| } |
| // Resolve any references that are created on this node. |
| node.references.forEach(function (ref) { |
| var dirTarget = null; |
| // If the reference expression is empty, then it matches the "primary" directive on the node |
| // (if there is one). Otherwise it matches the host node itself (either an element or |
| // <ng-template> node). |
| if (ref.value.trim() === '') { |
| // This could be a reference to a component if there is one. |
| dirTarget = directives.find(function (dir) { return dir.isComponent; }) || null; |
| } |
| else { |
| // This is a reference to a directive exported via exportAs. One should exist. |
| dirTarget = |
| directives.find(function (dir) { return dir.exportAs !== null && dir.exportAs.some(function (value) { return value === ref.value; }); }) || |
| null; |
| // Check if a matching directive was found, and error if it wasn't. |
| if (dirTarget === null) { |
| // TODO(alxhub): Return an error value here that can be used for template validation. |
| throw new Error("Assertion error: failed to find directive with exportAs: " + ref.value); |
| } |
| } |
| if (dirTarget !== null) { |
| // This reference points to a directive. |
| _this.references.set(ref, { directive: dirTarget, node: node }); |
| } |
| else { |
| // This reference points to the node itself. |
| _this.references.set(ref, node); |
| } |
| }); |
| // Associate attributes/bindings on the node with directives or with the node itself. |
| var processAttribute = function (attribute) { |
| var dir = directives.find(function (dir) { return dir.inputs.hasOwnProperty(attribute.name); }); |
| if (dir !== undefined) { |
| _this.bindings.set(attribute, dir); |
| } |
| else { |
| _this.bindings.set(attribute, node); |
| } |
| }; |
| node.attributes.forEach(processAttribute); |
| node.inputs.forEach(processAttribute); |
| node.outputs.forEach(processAttribute); |
| if (node instanceof Template) { |
| node.templateAttrs.forEach(processAttribute); |
| } |
| // Recurse into the node's children. |
| node.children.forEach(function (child) { return child.visit(_this); }); |
| }; |
| // Unused visitors. |
| DirectiveBinder.prototype.visitContent = function (content) { }; |
| DirectiveBinder.prototype.visitVariable = function (variable) { }; |
| DirectiveBinder.prototype.visitReference = function (reference) { }; |
| DirectiveBinder.prototype.visitTextAttribute = function (attribute) { }; |
| DirectiveBinder.prototype.visitBoundAttribute = function (attribute) { }; |
| DirectiveBinder.prototype.visitBoundEvent = function (attribute) { }; |
| DirectiveBinder.prototype.visitBoundAttributeOrEvent = function (node) { }; |
| DirectiveBinder.prototype.visitText = function (text) { }; |
| DirectiveBinder.prototype.visitBoundText = function (text) { }; |
| DirectiveBinder.prototype.visitIcu = function (icu) { }; |
| return DirectiveBinder; |
| }()); |
| /** |
| * Processes a template and extract metadata about expressions and symbols within. |
| * |
| * This is a companion to the `DirectiveBinder` that doesn't require knowledge of directives matched |
| * within the template in order to operate. |
| * |
| * Expressions are visited by the superclass `RecursiveAstVisitor`, with custom logic provided |
| * by overridden methods from that visitor. |
| */ |
| var TemplateBinder = /** @class */ (function (_super) { |
| __extends(TemplateBinder, _super); |
| function TemplateBinder(bindings, symbols, usedPipes, nestingLevel, scope, template, level) { |
| var _this = _super.call(this) || this; |
| _this.bindings = bindings; |
| _this.symbols = symbols; |
| _this.usedPipes = usedPipes; |
| _this.nestingLevel = nestingLevel; |
| _this.scope = scope; |
| _this.template = template; |
| _this.level = level; |
| _this.pipesUsed = []; |
| // Save a bit of processing time by constructing this closure in advance. |
| _this.visitNode = function (node) { return node.visit(_this); }; |
| return _this; |
| } |
| /** |
| * Process a template and extract metadata about expressions and symbols within. |
| * |
| * @param template the nodes of the template to process |
| * @param scope the `Scope` of the template being processed. |
| * @returns three maps which contain metadata about the template: `expressions` which interprets |
| * special `AST` nodes in expressions as pointing to references or variables declared within the |
| * template, `symbols` which maps those variables and references to the nested `Template` which |
| * declares them, if any, and `nestingLevel` which associates each `Template` with a integer |
| * nesting level (how many levels deep within the template structure the `Template` is), starting |
| * at 1. |
| */ |
| TemplateBinder.apply = function (template, scope) { |
| var expressions = new Map(); |
| var symbols = new Map(); |
| var nestingLevel = new Map(); |
| var usedPipes = new Set(); |
| // The top-level template has nesting level 0. |
| var binder = new TemplateBinder(expressions, symbols, usedPipes, nestingLevel, scope, template instanceof Template ? template : null, 0); |
| binder.ingest(template); |
| return { expressions: expressions, symbols: symbols, nestingLevel: nestingLevel, usedPipes: usedPipes }; |
| }; |
| TemplateBinder.prototype.ingest = function (template) { |
| if (template instanceof Template) { |
| // For <ng-template>s, process only variables and child nodes. Inputs, outputs, templateAttrs, |
| // and references were all processed in the scope of the containing template. |
| template.variables.forEach(this.visitNode); |
| template.children.forEach(this.visitNode); |
| // Set the nesting level. |
| this.nestingLevel.set(template, this.level); |
| } |
| else { |
| // Visit each node from the top-level template. |
| template.forEach(this.visitNode); |
| } |
| }; |
| TemplateBinder.prototype.visitElement = function (element) { |
| // Visit the inputs, outputs, and children of the element. |
| element.inputs.forEach(this.visitNode); |
| element.outputs.forEach(this.visitNode); |
| element.children.forEach(this.visitNode); |
| }; |
| TemplateBinder.prototype.visitTemplate = function (template) { |
| // First, visit inputs, outputs and template attributes of the template node. |
| template.inputs.forEach(this.visitNode); |
| template.outputs.forEach(this.visitNode); |
| template.templateAttrs.forEach(this.visitNode); |
| // References are also evaluated in the outer context. |
| template.references.forEach(this.visitNode); |
| // Next, recurse into the template using its scope, and bumping the nesting level up by one. |
| var childScope = this.scope.getChildScope(template); |
| var binder = new TemplateBinder(this.bindings, this.symbols, this.usedPipes, this.nestingLevel, childScope, template, this.level + 1); |
| binder.ingest(template); |
| }; |
| TemplateBinder.prototype.visitVariable = function (variable) { |
| // Register the `Variable` as a symbol in the current `Template`. |
| if (this.template !== null) { |
| this.symbols.set(variable, this.template); |
| } |
| }; |
| TemplateBinder.prototype.visitReference = function (reference) { |
| // Register the `Reference` as a symbol in the current `Template`. |
| if (this.template !== null) { |
| this.symbols.set(reference, this.template); |
| } |
| }; |
| // Unused template visitors |
| TemplateBinder.prototype.visitText = function (text) { }; |
| TemplateBinder.prototype.visitContent = function (content) { }; |
| TemplateBinder.prototype.visitTextAttribute = function (attribute) { }; |
| TemplateBinder.prototype.visitIcu = function (icu) { }; |
| // The remaining visitors are concerned with processing AST expressions within template bindings |
| TemplateBinder.prototype.visitBoundAttribute = function (attribute) { attribute.value.visit(this); }; |
| TemplateBinder.prototype.visitBoundEvent = function (event) { event.handler.visit(this); }; |
| TemplateBinder.prototype.visitBoundText = function (text) { text.value.visit(this); }; |
| TemplateBinder.prototype.visitPipe = function (ast, context) { |
| this.usedPipes.add(ast.name); |
| return _super.prototype.visitPipe.call(this, ast, context); |
| }; |
| // These five types of AST expressions can refer to expression roots, which could be variables |
| // or references in the current scope. |
| TemplateBinder.prototype.visitPropertyRead = function (ast, context) { |
| this.maybeMap(context, ast, ast.name); |
| return _super.prototype.visitPropertyRead.call(this, ast, context); |
| }; |
| TemplateBinder.prototype.visitSafePropertyRead = function (ast, context) { |
| this.maybeMap(context, ast, ast.name); |
| return _super.prototype.visitSafePropertyRead.call(this, ast, context); |
| }; |
| TemplateBinder.prototype.visitPropertyWrite = function (ast, context) { |
| this.maybeMap(context, ast, ast.name); |
| return _super.prototype.visitPropertyWrite.call(this, ast, context); |
| }; |
| TemplateBinder.prototype.visitMethodCall = function (ast, context) { |
| this.maybeMap(context, ast, ast.name); |
| return _super.prototype.visitMethodCall.call(this, ast, context); |
| }; |
| TemplateBinder.prototype.visitSafeMethodCall = function (ast, context) { |
| this.maybeMap(context, ast, ast.name); |
| return _super.prototype.visitSafeMethodCall.call(this, ast, context); |
| }; |
| TemplateBinder.prototype.maybeMap = function (scope, ast, name) { |
| // If the receiver of the expression isn't the `ImplicitReceiver`, this isn't the root of an |
| // `AST` expression that maps to a `Variable` or `Reference`. |
| if (!(ast.receiver instanceof ImplicitReceiver)) { |
| return; |
| } |
| // Check whether the name exists in the current scope. If so, map it. Otherwise, the name is |
| // probably a property on the top-level component context. |
| var target = this.scope.lookup(name); |
| if (target !== null) { |
| this.bindings.set(ast, target); |
| } |
| }; |
| return TemplateBinder; |
| }(RecursiveAstVisitor$1)); |
| /** |
| * Metadata container for a `Target` that allows queries for specific bits of metadata. |
| * |
| * See `BoundTarget` for documentation on the individual methods. |
| */ |
| var R3BoundTarget = /** @class */ (function () { |
| function R3BoundTarget(target, directives, bindings, references, exprTargets, symbols, nestingLevel, usedPipes) { |
| this.target = target; |
| this.directives = directives; |
| this.bindings = bindings; |
| this.references = references; |
| this.exprTargets = exprTargets; |
| this.symbols = symbols; |
| this.nestingLevel = nestingLevel; |
| this.usedPipes = usedPipes; |
| } |
| R3BoundTarget.prototype.getDirectivesOfNode = function (node) { |
| return this.directives.get(node) || null; |
| }; |
| R3BoundTarget.prototype.getReferenceTarget = function (ref) { |
| return this.references.get(ref) || null; |
| }; |
| R3BoundTarget.prototype.getConsumerOfBinding = function (binding) { |
| return this.bindings.get(binding) || null; |
| }; |
| R3BoundTarget.prototype.getExpressionTarget = function (expr) { |
| return this.exprTargets.get(expr) || null; |
| }; |
| R3BoundTarget.prototype.getTemplateOfSymbol = function (symbol) { |
| return this.symbols.get(symbol) || null; |
| }; |
| R3BoundTarget.prototype.getNestingLevel = function (template) { return this.nestingLevel.get(template) || 0; }; |
| R3BoundTarget.prototype.getUsedDirectives = function () { |
| var set = new Set(); |
| this.directives.forEach(function (dirs) { return dirs.forEach(function (dir) { return set.add(dir); }); }); |
| return Array.from(set.values()); |
| }; |
| R3BoundTarget.prototype.getUsedPipes = function () { return Array.from(this.usedPipes); }; |
| return R3BoundTarget; |
| }()); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| // This file only reexports content of the `src` folder. Keep it that way. |
| // This function call has a global side effects and publishes the compiler into global namespace for |
| // the late binding of the Compiler to the @angular/core for jit compilation. |
| publishFacade(_global); |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| // This file only reexports content of the `src` folder. Keep it that way. |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| |
| /** |
| * @license |
| * Copyright Google Inc. All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| |
| exports.core = core; |
| exports.CompilerConfig = CompilerConfig; |
| exports.preserveWhitespacesDefault = preserveWhitespacesDefault; |
| exports.isLoweredSymbol = isLoweredSymbol; |
| exports.createLoweredSymbol = createLoweredSymbol; |
| exports.Identifiers = Identifiers; |
| exports.JitCompiler = JitCompiler; |
| exports.ConstantPool = ConstantPool; |
| exports.DirectiveResolver = DirectiveResolver; |
| exports.PipeResolver = PipeResolver; |
| exports.NgModuleResolver = NgModuleResolver; |
| exports.DEFAULT_INTERPOLATION_CONFIG = DEFAULT_INTERPOLATION_CONFIG; |
| exports.InterpolationConfig = InterpolationConfig; |
| exports.NgModuleCompiler = NgModuleCompiler; |
| exports.ArrayType = ArrayType; |
| exports.AssertNotNull = AssertNotNull; |
| exports.DYNAMIC_TYPE = DYNAMIC_TYPE; |
| exports.BinaryOperatorExpr = BinaryOperatorExpr; |
| exports.BuiltinType = BuiltinType; |
| exports.CastExpr = CastExpr; |
| exports.ClassField = ClassField; |
| exports.ClassMethod = ClassMethod; |
| exports.ClassStmt = ClassStmt; |
| exports.CommaExpr = CommaExpr; |
| exports.CommentStmt = CommentStmt; |
| exports.ConditionalExpr = ConditionalExpr; |
| exports.DeclareFunctionStmt = DeclareFunctionStmt; |
| exports.DeclareVarStmt = DeclareVarStmt; |
| exports.Expression = Expression; |
| exports.ExpressionStatement = ExpressionStatement; |
| exports.ExpressionType = ExpressionType; |
| exports.ExternalExpr = ExternalExpr; |
| exports.ExternalReference = ExternalReference; |
| exports.literalMap = literalMap; |
| exports.FunctionExpr = FunctionExpr; |
| exports.IfStmt = IfStmt; |
| exports.InstantiateExpr = InstantiateExpr; |
| exports.InvokeFunctionExpr = InvokeFunctionExpr; |
| exports.InvokeMethodExpr = InvokeMethodExpr; |
| exports.JSDocCommentStmt = JSDocCommentStmt; |
| exports.LiteralArrayExpr = LiteralArrayExpr; |
| exports.LiteralExpr = LiteralExpr; |
| exports.LiteralMapExpr = LiteralMapExpr; |
| exports.MapType = MapType; |
| exports.NotExpr = NotExpr; |
| exports.ReadKeyExpr = ReadKeyExpr; |
| exports.ReadPropExpr = ReadPropExpr; |
| exports.ReadVarExpr = ReadVarExpr; |
| exports.ReturnStatement = ReturnStatement; |
| exports.ThrowStmt = ThrowStmt; |
| exports.TryCatchStmt = TryCatchStmt; |
| exports.Type = Type$1; |
| exports.WrappedNodeExpr = WrappedNodeExpr; |
| exports.WriteKeyExpr = WriteKeyExpr; |
| exports.WritePropExpr = WritePropExpr; |
| exports.WriteVarExpr = WriteVarExpr; |
| exports.Statement = Statement; |
| exports.TypeofExpr = TypeofExpr; |
| exports.collectExternalReferences = collectExternalReferences; |
| exports.EmitterVisitorContext = EmitterVisitorContext; |
| exports.JitEvaluator = JitEvaluator; |
| exports.ViewCompiler = ViewCompiler; |
| exports.findStaticQueryIds = findStaticQueryIds; |
| exports.staticViewQueryIds = staticViewQueryIds; |
| exports.getParseErrors = getParseErrors; |
| exports.isSyntaxError = isSyntaxError; |
| exports.syntaxError = syntaxError; |
| exports.Version = Version; |
| exports.TmplAstBoundAttribute = BoundAttribute; |
| exports.TmplAstBoundEvent = BoundEvent; |
| exports.TmplAstBoundText = BoundText; |
| exports.TmplAstContent = Content; |
| exports.TmplAstElement = Element; |
| exports.TmplAstReference = Reference; |
| exports.TmplAstTemplate = Template; |
| exports.TmplAstText = Text; |
| exports.TmplAstTextAttribute = TextAttribute; |
| exports.TmplAstVariable = Variable; |
| exports.R3Identifiers = Identifiers$1; |
| exports.compileInjector = compileInjector; |
| exports.compileNgModule = compileNgModule; |
| exports.compilePipeFromMetadata = compilePipeFromMetadata; |
| exports.makeBindingParser = makeBindingParser; |
| exports.parseTemplate = parseTemplate; |
| exports.compileBaseDefFromMetadata = compileBaseDefFromMetadata; |
| exports.compileComponentFromMetadata = compileComponentFromMetadata; |
| exports.compileDirectiveFromMetadata = compileDirectiveFromMetadata; |
| exports.parseHostBindings = parseHostBindings; |
| exports.verifyHostBindings = verifyHostBindings; |
| exports.publishFacade = publishFacade; |
| exports.VERSION = VERSION$1; |
| exports.TextAst = TextAst; |
| exports.BoundTextAst = BoundTextAst; |
| exports.AttrAst = AttrAst; |
| exports.BoundElementPropertyAst = BoundElementPropertyAst; |
| exports.BoundEventAst = BoundEventAst; |
| exports.ReferenceAst = ReferenceAst; |
| exports.VariableAst = VariableAst; |
| exports.ElementAst = ElementAst; |
| exports.EmbeddedTemplateAst = EmbeddedTemplateAst; |
| exports.BoundDirectivePropertyAst = BoundDirectivePropertyAst; |
| exports.DirectiveAst = DirectiveAst; |
| exports.ProviderAst = ProviderAst; |
| exports.NgContentAst = NgContentAst; |
| exports.NullTemplateVisitor = NullTemplateVisitor; |
| exports.RecursiveTemplateAstVisitor = RecursiveTemplateAstVisitor; |
| exports.templateVisitAll = templateVisitAll; |
| exports.sanitizeIdentifier = sanitizeIdentifier; |
| exports.identifierName = identifierName; |
| exports.identifierModuleUrl = identifierModuleUrl; |
| exports.viewClassName = viewClassName; |
| exports.rendererTypeName = rendererTypeName; |
| exports.hostViewClassName = hostViewClassName; |
| exports.componentFactoryName = componentFactoryName; |
| exports.tokenName = tokenName; |
| exports.tokenReference = tokenReference; |
| exports.CompileStylesheetMetadata = CompileStylesheetMetadata; |
| exports.CompileTemplateMetadata = CompileTemplateMetadata; |
| exports.CompileDirectiveMetadata = CompileDirectiveMetadata; |
| exports.CompilePipeMetadata = CompilePipeMetadata; |
| exports.CompileShallowModuleMetadata = CompileShallowModuleMetadata; |
| exports.CompileNgModuleMetadata = CompileNgModuleMetadata; |
| exports.TransitiveCompileNgModuleMetadata = TransitiveCompileNgModuleMetadata; |
| exports.ProviderMeta = ProviderMeta; |
| exports.flatten = flatten; |
| exports.templateSourceUrl = templateSourceUrl; |
| exports.sharedStylesheetJitUrl = sharedStylesheetJitUrl; |
| exports.ngModuleJitUrl = ngModuleJitUrl; |
| exports.templateJitUrl = templateJitUrl; |
| exports.createAotUrlResolver = createAotUrlResolver; |
| exports.createAotCompiler = createAotCompiler; |
| exports.AotCompiler = AotCompiler; |
| exports.analyzeNgModules = analyzeNgModules; |
| exports.analyzeAndValidateNgModules = analyzeAndValidateNgModules; |
| exports.analyzeFile = analyzeFile; |
| exports.analyzeFileForInjectables = analyzeFileForInjectables; |
| exports.mergeAnalyzedFiles = mergeAnalyzedFiles; |
| exports.GeneratedFile = GeneratedFile; |
| exports.toTypeScript = toTypeScript; |
| exports.formattedError = formattedError; |
| exports.isFormattedError = isFormattedError; |
| exports.StaticReflector = StaticReflector; |
| exports.StaticSymbol = StaticSymbol; |
| exports.StaticSymbolCache = StaticSymbolCache; |
| exports.ResolvedStaticSymbol = ResolvedStaticSymbol; |
| exports.StaticSymbolResolver = StaticSymbolResolver; |
| exports.unescapeIdentifier = unescapeIdentifier; |
| exports.unwrapResolvedMetadata = unwrapResolvedMetadata; |
| exports.AotSummaryResolver = AotSummaryResolver; |
| exports.AstPath = AstPath; |
| exports.SummaryResolver = SummaryResolver; |
| exports.JitSummaryResolver = JitSummaryResolver; |
| exports.CompileReflector = CompileReflector; |
| exports.createUrlResolverWithoutPackagePrefix = createUrlResolverWithoutPackagePrefix; |
| exports.createOfflineCompileUrlResolver = createOfflineCompileUrlResolver; |
| exports.UrlResolver = UrlResolver; |
| exports.getUrlScheme = getUrlScheme; |
| exports.ResourceLoader = ResourceLoader; |
| exports.ElementSchemaRegistry = ElementSchemaRegistry; |
| exports.Extractor = Extractor; |
| exports.I18NHtmlParser = I18NHtmlParser; |
| exports.MessageBundle = MessageBundle; |
| exports.Serializer = Serializer; |
| exports.Xliff = Xliff; |
| exports.Xliff2 = Xliff2; |
| exports.Xmb = Xmb; |
| exports.Xtb = Xtb; |
| exports.DirectiveNormalizer = DirectiveNormalizer; |
| exports.ParserError = ParserError; |
| exports.ParseSpan = ParseSpan; |
| exports.AST = AST; |
| exports.Quote = Quote; |
| exports.EmptyExpr = EmptyExpr; |
| exports.ImplicitReceiver = ImplicitReceiver; |
| exports.Chain = Chain; |
| exports.Conditional = Conditional; |
| exports.PropertyRead = PropertyRead; |
| exports.PropertyWrite = PropertyWrite; |
| exports.SafePropertyRead = SafePropertyRead; |
| exports.KeyedRead = KeyedRead; |
| exports.KeyedWrite = KeyedWrite; |
| exports.BindingPipe = BindingPipe; |
| exports.LiteralPrimitive = LiteralPrimitive; |
| exports.LiteralArray = LiteralArray; |
| exports.LiteralMap = LiteralMap; |
| exports.Interpolation = Interpolation; |
| exports.Binary = Binary; |
| exports.PrefixNot = PrefixNot; |
| exports.NonNullAssert = NonNullAssert; |
| exports.MethodCall = MethodCall; |
| exports.SafeMethodCall = SafeMethodCall; |
| exports.FunctionCall = FunctionCall; |
| exports.ASTWithSource = ASTWithSource; |
| exports.TemplateBinding = TemplateBinding; |
| exports.NullAstVisitor = NullAstVisitor; |
| exports.RecursiveAstVisitor = RecursiveAstVisitor$1; |
| exports.AstTransformer = AstTransformer$1; |
| exports.AstMemoryEfficientTransformer = AstMemoryEfficientTransformer; |
| exports.visitAstChildren = visitAstChildren; |
| exports.ParsedProperty = ParsedProperty; |
| exports.ParsedEvent = ParsedEvent; |
| exports.ParsedVariable = ParsedVariable; |
| exports.BoundElementProperty = BoundElementProperty; |
| exports.Lexer = Lexer; |
| exports.Token = Token$1; |
| exports.EOF = EOF; |
| exports.isIdentifier = isIdentifier; |
| exports.isQuote = isQuote; |
| exports.SplitInterpolation = SplitInterpolation; |
| exports.TemplateBindingParseResult = TemplateBindingParseResult; |
| exports.Parser = Parser$1; |
| exports._ParseAST = _ParseAST; |
| exports.ERROR_COMPONENT_TYPE = ERROR_COMPONENT_TYPE; |
| exports.CompileMetadataResolver = CompileMetadataResolver; |
| exports.Text = Text$3; |
| exports.Expansion = Expansion; |
| exports.ExpansionCase = ExpansionCase; |
| exports.Attribute = Attribute; |
| exports.Element = Element$1; |
| exports.Comment = Comment; |
| exports.visitAll = visitAll$1; |
| exports.RecursiveVisitor = RecursiveVisitor; |
| exports.findNode = findNode; |
| exports.HtmlParser = HtmlParser; |
| exports.ParseTreeResult = ParseTreeResult; |
| exports.TreeError = TreeError; |
| exports.HtmlTagDefinition = HtmlTagDefinition; |
| exports.getHtmlTagDefinition = getHtmlTagDefinition; |
| exports.splitNsName = splitNsName; |
| exports.isNgContainer = isNgContainer; |
| exports.isNgContent = isNgContent; |
| exports.isNgTemplate = isNgTemplate; |
| exports.getNsPrefix = getNsPrefix; |
| exports.mergeNsAndName = mergeNsAndName; |
| exports.NAMED_ENTITIES = NAMED_ENTITIES; |
| exports.NGSP_UNICODE = NGSP_UNICODE; |
| exports.debugOutputAstAsTypeScript = debugOutputAstAsTypeScript; |
| exports.TypeScriptEmitter = TypeScriptEmitter; |
| exports.ParseLocation = ParseLocation; |
| exports.ParseSourceFile = ParseSourceFile; |
| exports.ParseSourceSpan = ParseSourceSpan; |
| exports.ParseError = ParseError; |
| exports.typeSourceSpan = typeSourceSpan; |
| exports.r3JitTypeSourceSpan = r3JitTypeSourceSpan; |
| exports.DomElementSchemaRegistry = DomElementSchemaRegistry; |
| exports.CssSelector = CssSelector; |
| exports.SelectorMatcher = SelectorMatcher; |
| exports.SelectorListContext = SelectorListContext; |
| exports.SelectorContext = SelectorContext; |
| exports.HOST_ATTR = HOST_ATTR; |
| exports.CONTENT_ATTR = CONTENT_ATTR; |
| exports.StylesCompileDependency = StylesCompileDependency; |
| exports.CompiledStylesheet = CompiledStylesheet; |
| exports.StyleCompiler = StyleCompiler; |
| exports.TemplateParseError = TemplateParseError; |
| exports.TemplateParseResult = TemplateParseResult; |
| exports.TemplateParser = TemplateParser; |
| exports.splitClasses = splitClasses; |
| exports.createElementCssSelector = createElementCssSelector; |
| exports.removeSummaryDuplicates = removeSummaryDuplicates; |
| exports.isEmptyExpression = isEmptyExpression; |
| exports.compileInjectable = compileInjectable; |
| exports.R3TargetBinder = R3TargetBinder; |
| exports.R3BoundTarget = R3BoundTarget; |
| |
| Object.defineProperty(exports, '__esModule', { value: true }); |
| |
| })); |
| //# sourceMappingURL=compiler.umd.js.map |