Optimizations for mangling

Author: Anatoly Ostrovsky

@types/angular.d.ts

@@ -1,14 +1,14 @@
 export class Angular {
-  /** @public */
-  public $cache: Map<number, import("./interface.ts").ExpandoStore>;
+  _$cache: Map<number, import("./interface.ts").ExpandoStore>;
   /** @public @type {ng.PubSubService} */
   public $eventBus: ng.PubSubService;
   /**
+   * @public
    * @type {string} `version` from `package.json`
    */
-  version: string;
+  public version: string;
   /** @type {!Array<string|any>} */
-  bootsrappedModules: Array<string | any>;
+  _bootsrappedModules: Array<string | any>;
   /**
    * Gets the controller instance for a given element, if exists. Defaults to "ngControllerController"
    *

@types/core/parse/interpreter.d.ts

@@ -10,13 +10,15 @@ export class ASTInterpreter {
    * @param {function(any):any} $filter
    */
   constructor($filter: (arg0: any) => any);
-  $filter: (arg0: any) => any;
+  _$filter: (arg0: any) => any;
   /**
    * Compiles the AST into a function.
-   * @param {import("./ast/ast").ASTNode} ast - The AST to compile.
+   * @param {import("./ast/ast.js").ASTNode} ast - The AST to compile.
    * @returns {import("./interface.ts").CompiledExpression}
    */
-  compile(ast: any): import("./interface.ts").CompiledExpression;
+  compile(
+    ast: import("./ast/ast.js").ASTNode,
+  ): import("./interface.ts").CompiledExpression;
   /**
    * Unary plus operation.
    * @param {function} argument - The argument function.

@types/router/glob/glob.d.ts

@@ -64,15 +64,11 @@ export class Glob {
   /**
    * @type {string}
    */
-  text: string;
-  /**
-   * @type {string[]}
-   */
-  glob: string[];
+  _text: string;
   /**
    * @type {RegExp}
    */
-  regexp: RegExp;
+  _regexp: RegExp;
   /**
    * @param {string} name
    * @return {boolean}

@types/router/router.d.ts

@@ -12,31 +12,33 @@ export class Router {
    * The parameter values from the latest successful transition
    * @type {StateParams}
    */
-  params: StateParams;
+  _params: StateParams;
   /**
    * @type {number}
    */
-  lastStartedTransitionId: number;
+  _lastStartedTransitionId: number;
   /**
    * @type {Queue<import("./transition/transition.js").Transition>}
    */
-  transitionHistory: Queue<import("./transition/transition.js").Transition>;
+  _transitionHistory: Queue<import("./transition/transition.js").Transition>;
   /**
    * @type {Queue<import("./transition/transition.js").Transition>}
    */
-  successfulTransitions: Queue<import("./transition/transition.js").Transition>;
+  _successfulTransitions: Queue<
+    import("./transition/transition.js").Transition
+  >;
   /**
    * @type {import("./state/interface.ts").StateDeclaration|undefined}
    */
-  current: import("./state/interface.ts").StateDeclaration | undefined;
+  _current: import("./state/interface.ts").StateDeclaration | undefined;
   /**
    * @type {import("./state/state-object.js").StateObject|undefined}
    */
-  $current: import("./state/state-object.js").StateObject | undefined;
+  _$current: import("./state/state-object.js").StateObject | undefined;
   /**
    * @type {import("./transition/transition.js").Transition|undefined}
    */
-  transition: import("./transition/transition.js").Transition | undefined;
+  _transition: import("./transition/transition.js").Transition | undefined;
   $get: () => this;
 }
 /**

@types/router/transition/transition.d.ts

@@ -28,8 +28,8 @@ export class Transition implements IHookRegistry {
   /**
    * @type {import('../router.js').Router}
    */
-  globals: import("../router.js").Router;
-  transitionService: import("../transition/transition-service.js").TransitionProvider;
+  _globals: import("../router.js").Router;
+  _transitionService: import("../transition/transition-service.js").TransitionProvider;
   _deferred: any;
   /**
    * This promise is resolved or rejected based on the outcome of the Transition.

@types/router/view/view.d.ts

@@ -11,13 +11,13 @@ export class ViewService {
     context: import("../state/state-object.js").StateObject | null,
   ): import("../state/state-object.js").StateObject | null;
   _rootContext: any;
-  viewConfigFactory(factory: any): void;
+  _viewConfigFactory(factory: any): void;
   /**
    * @param path
    * @param decl
    * @return {import("../state/views.js").ViewConfig}
    */
-  createViewConfig(
+  _createViewConfig(
     path: any,
     decl: any,
   ): import("../state/views.js").ViewConfig;

@types/shared/utils.d.ts

@@ -426,7 +426,6 @@ export function encodeUriSegment(val: string): string;
  *                     / "*" / "+" / "," / ";" / "="
  */
 export function encodeUriQuery(val: any, pctEncodeSpaces: any): string;
-export function getNgAttribute(element: any, ngAttr: any): any;
 /**
  * Creates a shallow copy of an object, an array or a primitive.
  *

src/angular.js

@@ -1,7 +1,6 @@
 import {
   assertNotHasOwnProperty,
   errorHandlingConfig,
-  getNgAttribute,
   hasOwn,
   isArray,
   minErr,
@@ -26,24 +25,27 @@ const ngMinErr = minErr("ng");
 
 const $injectorMinErr = minErr("$injector");
 
+const STRICT_DI = "strict-di";
+
 /** @type {Object.<string, NgModule>} */
 const moduleRegistry = {};
 
 export class Angular {
   constructor() {
-    /** @public */
-    this.$cache = Cache;
+    /* @ignore */
+    this._$cache = Cache;
 
     /** @public @type {ng.PubSubService} */
     this.$eventBus = EventBus;
 
     /**
+     * @public
      * @type {string} `version` from `package.json`
      */
     this.version = "[VI]{version}[/VI]"; //inserted via rollup plugin
 
     /** @type {!Array<string|any>} */
-    this.bootsrappedModules = [];
+    this._bootsrappedModules = [];
 
     /**
      * Gets the controller instance for a given element, if exists. Defaults to "ngControllerController"
@@ -194,10 +196,10 @@ export class Angular {
     }
 
     if (isArray(modules)) {
-      this.bootsrappedModules = modules;
+      this._bootsrappedModules = modules;
     }
 
-    this.bootsrappedModules.unshift([
+    this._bootsrappedModules.unshift([
       "$provide",
       /**
        * @param {import('./interface.ts').Provider} $provide
@@ -207,9 +209,9 @@ export class Angular {
       },
     ]);
 
-    this.bootsrappedModules.unshift("ng");
+    this._bootsrappedModules.unshift("ng");
 
-    const injector = createInjector(this.bootsrappedModules, config.strictDi);
+    const injector = createInjector(this._bootsrappedModules, config.strictDi);
 
     injector.invoke([
       $t.$rootScope,
@@ -278,6 +280,7 @@ export class Angular {
    * @param {Element|Document} element
    */
   init(element) {
+    /** @type {Element} */
     let appElement;
 
     let module;
@@ -292,12 +295,9 @@ export class Angular {
         /** @type {Element} */ (element).hasAttribute &&
         /** @type {Element} */ (element).hasAttribute(name)
       ) {
-        appElement = element;
+        appElement = /** @type {Element} */ (element);
         module = /** @type {Element} */ (element).getAttribute(name);
       }
-    });
-    ngAttrPrefixes.forEach((prefix) => {
-      const name = `${prefix}app`;
 
       let candidate;
 
@@ -311,7 +311,9 @@ export class Angular {
     });
 
     if (appElement) {
-      config.strictDi = getNgAttribute(appElement, "strict-di") !== null;
+      config.strictDi =
+        appElement.hasAttribute(STRICT_DI) ||
+        appElement.hasAttribute(`data-${STRICT_DI}`);
       this.bootstrap(appElement, module ? [module] : [], config);
     }
   }

src/core/parse/ast/ast.js

@@ -127,15 +127,11 @@ export class AST {
   _ternary() {
     const test = this._logicalOR();
 
-    let alternate;
-
-    let consequent;
-
     if (this._expect("?")) {
-      alternate = this._assignment();
+      const alternate = this._assignment();
 
       if (this._consume(":")) {
-        consequent = this._assignment();
+        const consequent = this._assignment();
 
         return {
           type: ASTType._ConditionalExpression,

src/core/parse/interpreter.js

@@ -16,24 +16,24 @@ export class ASTInterpreter {
    * @param {function(any):any} $filter
    */
   constructor($filter) {
-    this.$filter = $filter;
+    this._$filter = $filter;
   }
 
   /**
    * Compiles the AST into a function.
-   * @param {import("./ast/ast").ASTNode} ast - The AST to compile.
+   * @param {import("./ast/ast.js").ASTNode} ast - The AST to compile.
    * @returns {import("./interface.ts").CompiledExpression}
    */
   compile(ast) {
-    const decoratedNode = findConstantAndWatchExpressions(ast, this.$filter);
+    const decoratedNode = findConstantAndWatchExpressions(ast, this._$filter);
 
-    /** @type {import("./ast/ast").ASTNode} */
-    let assignable;
+    /** @type {import("./ast/ast.js").ASTNode} */
+    const assignable = assignableAST(decoratedNode);
 
     /** @type {import("./interface.ts").CompiledExpression} */
     let assign;
 
-    if ((assignable = assignableAST(decoratedNode))) {
+    if (assignable) {
       assign = /** @type {import("./interface.ts").CompiledExpression} */ (
         this.#recurse(assignable)
       );
@@ -167,7 +167,7 @@ export class ASTInterpreter {
           args.push(self.#recurse(expr));
         });
 
-        if (ast.filter) right = this.$filter(ast.callee.name);
+        if (ast.filter) right = this._$filter(ast.callee.name);
 
         if (!ast.filter) right = this.#recurse(ast.callee, true);