Additional mangle optimizations

Author: tolyo

src/router/common/trace.ts

@@ -131,13 +131,13 @@ function transLbl(trans: ng.Transition): string {
  */
 export class Trace {
   _enabled: Record<string, boolean>;
-  approximateDigests: number;
-  $logger: TraceLogger;
+  _approximateDigests: number;
+  _logger: TraceLogger;
 
   constructor() {
     this._enabled = {};
-    this.approximateDigests = 0;
-    this.$logger =
+    this._approximateDigests = 0;
+    this._logger =
       (window.angular?.$injector?.get($injectTokens._log) as
         | TraceLogger
         | undefined) || console;
@@ -175,13 +175,13 @@ export class Trace {
   /** @internal called by ng-router code */
   traceTransitionStart(trans: ng.Transition): void {
     if (!this.enabled(Category._TRANSITION)) return;
-    this.$logger.log(`${transLbl(trans)}: Started  -> ${stringify(trans)}`);
+    this._logger.log(`${transLbl(trans)}: Started  -> ${stringify(trans)}`);
   }
 
   /** @internal called by ng-router code */
   traceTransitionIgnored(trans: ng.Transition): void {
     if (!this.enabled(Category._TRANSITION)) return;
-    this.$logger.log(`${transLbl(trans)}: Ignored  <> ${stringify(trans)}`);
+    this._logger.log(`${transLbl(trans)}: Ignored  <> ${stringify(trans)}`);
   }
 
   /** @internal called by ng-router code */
@@ -198,15 +198,15 @@ export class Trace {
         "unknown",
       name = functionToString(step.registeredHook.callback);
 
-    this.$logger.log(
+    this._logger.log(
       `${transLbl(trans)}:   Hook -> ${event} context: ${context}, ${maxLength(200, name)}`,
     );
   }
 
   /** @internal called by ng-router code */
   traceHookResult(hookResult: HookResult, trans: ng.Transition): void {
     if (!this.enabled(Category._HOOK)) return;
-    this.$logger.log(
+    this._logger.log(
       `${transLbl(trans)}:   <- Hook returned: ${maxLength(200, stringify(hookResult))}`,
     );
   }
@@ -218,29 +218,29 @@ export class Trace {
     trans: ng.Transition,
   ): void {
     if (!this.enabled(Category._RESOLVE)) return;
-    this.$logger.log(`${transLbl(trans)}:         Resolving ${path} (${when})`);
+    this._logger.log(`${transLbl(trans)}:         Resolving ${path} (${when})`);
   }
 
   /** @internal called by ng-router code */
   traceResolvableResolved(resolvable: Resolvable, trans: ng.Transition): void {
     if (!this.enabled(Category._RESOLVE)) return;
-    this.$logger.log(
+    this._logger.log(
       `${transLbl(trans)}:               <- Resolved  ${resolvable} to: ${maxLength(200, stringify(resolvable.data))}`,
     );
   }
 
   /** @internal called by ng-router code */
   traceError(reason: unknown, trans: ng.Transition): void {
     if (!this.enabled(Category._TRANSITION)) return;
-    this.$logger.log(
+    this._logger.log(
       `${transLbl(trans)}: <- Rejected ${stringify(trans)}, reason: ${reason}`,
     );
   }
 
   /** @internal called by ng-router code */
   traceSuccess(finalState: StateObject, trans: ng.Transition): void {
     if (!this.enabled(Category._TRANSITION)) return;
-    this.$logger.log(
+    this._logger.log(
       `${transLbl(trans)}: <- Success  ${stringify(trans)}, final state: ${finalState.name}`,
     );
   }
@@ -252,7 +252,7 @@ export class Trace {
     extra = "",
   ): void {
     if (!this.enabled(Category._UIVIEW)) return;
-    this.$logger.log(
+    this._logger.log(
       `ng-view: ${padString(MAX_PAD_LENGTH, event)} ${ngViewString(viewData)}${extra}`,
     );
   }
@@ -295,19 +295,19 @@ export class Trace {
       })
       .sort((a, b) => (a[uivheader] || "").localeCompare(b[uivheader] || ""));
 
-    this.$logger.table(mapping);
+    this._logger.table(mapping);
   }
 
   /** @internal called by ng-router code */
   traceViewServiceEvent(event: string, viewConfig: ViewConfig): void {
     if (!this.enabled(Category._VIEWCONFIG)) return;
-    this.$logger.log(`VIEWCONFIG: ${event} ${viewConfigString(viewConfig)}`);
+    this._logger.log(`VIEWCONFIG: ${event} ${viewConfigString(viewConfig)}`);
   }
 
   /** @internal called by ng-router code */
   traceViewServiceUIViewEvent(event: string, viewData: ActiveUIView): void {
     if (!this.enabled(Category._VIEWCONFIG)) return;
-    this.$logger.log(`VIEWCONFIG: ${event} ${ngViewString(viewData)}`);
+    this._logger.log(`VIEWCONFIG: ${event} ${ngViewString(viewData)}`);
   }
 }
 /**

src/router/state/state-service.ts

@@ -292,7 +292,7 @@ export class StateProvider {
 
     const { globals } = this;
 
-    const latestThing = () => globals._transitionHistory.peekTail();
+    const latestThing = () => globals._transitionHistory._peekTail();
 
     const latest = latestThing();
 
@@ -333,7 +333,7 @@ export class StateProvider {
      * @returns {Promise<any>}
      */
     function invokeNextCallback(): Promise<any> {
-      const nextCallback = callbackQueue.dequeue();
+      const nextCallback = callbackQueue._dequeue();
 
       if (nextCallback === undefined)
         return Rejection.invalid(toState.error()).toPromise();
@@ -517,7 +517,7 @@ export class StateProvider {
   getCurrentPath(): PathNode[] {
     const { globals } = this;
 
-    const latestSuccess = globals._successfulTransitions.peekTail();
+    const latestSuccess = globals._successfulTransitions._peekTail();
 
     const rootPath = () => [new PathNode(this._getRegistry().root())];
 

src/router/template-factory.ts

@@ -27,10 +27,10 @@ type TemplateResult =
  * Resolves route templates and components from state view declarations.
  */
 export class TemplateFactoryProvider {
-  $templateRequest: ng.TemplateRequestService | undefined;
-  $http: ng.HttpService | undefined;
-  $templateCache: ng.TemplateCacheService | undefined;
-  $injector: ng.InjectorService | undefined;
+  _templateRequest: ng.TemplateRequestService | undefined;
+  _http: ng.HttpService | undefined;
+  _templateCache: ng.TemplateCacheService | undefined;
+  _injector: ng.InjectorService | undefined;
 
   /**
    * Wires HTTP, template request, cache, and injector services into the factory.
@@ -46,10 +46,10 @@ export class TemplateFactoryProvider {
       $templateRequest: ng.TemplateRequestService,
       $injector: ng.InjectorService,
     ): TemplateFactoryProvider => {
-      this.$templateRequest = $templateRequest;
-      this.$http = $http;
-      this.$templateCache = $templateCache;
-      this.$injector = $injector;
+      this._templateRequest = $templateRequest;
+      this._http = $http;
+      this._templateCache = $templateCache;
+      this._injector = $injector;
 
       return this;
     },
@@ -130,7 +130,7 @@ export class TemplateFactoryProvider {
 
     if (isNullOrUndefined(url)) return null;
 
-    return this.$templateRequest!(url as string);
+    return this._templateRequest!(url as string);
   }
 
   fromProvider(
@@ -211,7 +211,7 @@ export class TemplateFactoryProvider {
       return `${attrName}='$resolve.${resolveName}'`;
     };
 
-    const attrs = getComponentBindings(this.$injector, component)
+    const attrs = getComponentBindings(this._injector, component)
       .map(attributeTpl)
       .join(" ");
 

src/router/transition/transition-service.ts

@@ -152,7 +152,7 @@ export class TransitionProvider implements TransitionService {
     this._defineCoreEvents();
     this._registerCoreTransitionHooks();
     this._exceptionHandler = $exceptionHandler.handler;
-    globals._successfulTransitions.onEvict(treeChangesCleanup);
+    globals._successfulTransitions._onEvict(treeChangesCleanup);
   }
 
   /**
@@ -536,7 +536,7 @@ function registerUpdateGlobalState(
     const transitionSuccessful = (): void => {
       const current = trans.$to();
 
-      globals._successfulTransitions.enqueue(trans);
+      globals._successfulTransitions._enqueue(trans);
       globals.$current = current;
       globals.current = current?.self;
       copy(trans.params(), globals.params);

src/router/transition/transition.ts

@@ -883,7 +883,7 @@ export class Transition {
 
       _globals._lastStartedTransitionId = this.$id;
       _globals.transition = this;
-      _globals._transitionHistory.enqueue(this);
+      _globals._transitionHistory._enqueue(this);
       trace.traceTransitionStart(this);
 
       return Promise.resolve();

src/shared/common.spec.js

@@ -190,103 +190,103 @@ describe("common", function () {
   });
 
   describe("Queue", () => {
-    it("peekTail() should show the last enqueued item", () => {
+    it("_peekTail() should show the last enqueued item", () => {
       const q = new Queue();
-      q.enqueue(1);
-      q.enqueue(2);
-      q.enqueue(3);
-      expect(q.size()).toBe(3);
-      expect(q.peekTail()).toBe(3);
+      q._enqueue(1);
+      q._enqueue(2);
+      q._enqueue(3);
+      expect(q._size()).toBe(3);
+      expect(q._peekTail()).toBe(3);
     });
 
-    it("peekHead() should show the first enqueued item", () => {
+    it("_peekHead() should show the first enqueued item", () => {
       const q = new Queue();
-      q.enqueue(1);
-      q.enqueue(2);
-      q.enqueue(3);
-      expect(q.size()).toBe(3);
-      expect(q.peekHead()).toBe(1);
+      q._enqueue(1);
+      q._enqueue(2);
+      q._enqueue(3);
+      expect(q._size()).toBe(3);
+      expect(q._peekHead()).toBe(1);
     });
 
     it("should support a limit (max number of items)", () => {
       const q = new Queue([], 2);
-      q.enqueue(1);
-      q.enqueue(2);
-      q.enqueue(3);
-      expect(q.size()).toBe(2);
-      expect(q.peekHead()).toBe(2);
-      expect(q.peekTail()).toBe(3);
+      q._enqueue(1);
+      q._enqueue(2);
+      q._enqueue(3);
+      expect(q._size()).toBe(2);
+      expect(q._peekHead()).toBe(2);
+      expect(q._peekTail()).toBe(3);
     });
 
-    it("clear() should remove all items", () => {
+    it("_clear() should remove all items", () => {
       const q = new Queue([], 2);
-      q.enqueue(1);
-      q.enqueue(2);
-      q.enqueue(3);
-      expect(q.size()).toBe(2);
+      q._enqueue(1);
+      q._enqueue(2);
+      q._enqueue(3);
+      expect(q._size()).toBe(2);
 
-      q.clear();
-      expect(q.size()).toBe(0);
+      q._clear();
+      expect(q._size()).toBe(0);
     });
 
-    it("enqueue() should evict from the head when max length is reached", () => {
+    it("_enqueue() should evict from the head when max length is reached", () => {
       const q = new Queue([], 3);
-      q.enqueue(1);
-      q.enqueue(2);
-      q.enqueue(3);
-      expect(q.size()).toBe(3);
+      q._enqueue(1);
+      q._enqueue(2);
+      q._enqueue(3);
+      expect(q._size()).toBe(3);
 
-      q.enqueue(4);
-      expect(q.size()).toBe(3);
+      q._enqueue(4);
+      expect(q._size()).toBe(3);
 
-      const a = q.dequeue();
-      const b = q.dequeue();
-      const c = q.dequeue();
+      const a = q._dequeue();
+      const b = q._dequeue();
+      const c = q._dequeue();
 
-      expect(q.size()).toBe(0);
+      expect(q._size()).toBe(0);
       expect([a, b, c]).toEqual([2, 3, 4]);
     });
 
-    it("onEvict() handlers should be called when an item is evicted", () => {
+    it("_onEvict() handlers should be called when an item is evicted", () => {
       const log = [];
       const q = new Queue([], 2);
 
-      q.onEvict((item) => log.push(item));
+      q._onEvict((item) => log.push(item));
 
-      q.enqueue(1);
-      expect(q.size()).toBe(1);
+      q._enqueue(1);
+      expect(q._size()).toBe(1);
       expect(log).toEqual([]);
 
-      q.enqueue(2);
-      expect(q.size()).toBe(2);
+      q._enqueue(2);
+      expect(q._size()).toBe(2);
       expect(log).toEqual([]);
 
-      q.enqueue(3);
-      expect(q.size()).toBe(2);
+      q._enqueue(3);
+      expect(q._size()).toBe(2);
       expect(log).toEqual([1]);
 
-      q.enqueue(4);
-      expect(q.size()).toBe(2);
+      q._enqueue(4);
+      expect(q._size()).toBe(2);
       expect(log).toEqual([1, 2]);
     });
 
-    it("onEvict() should support multiple handlers", () => {
+    it("_onEvict() should support multiple handlers", () => {
       const log = [];
       const log2 = [];
       const q = new Queue([], 2);
 
-      q.onEvict((item) => log.push(item));
-      q.onEvict((item) => log2.push(item));
+      q._onEvict((item) => log.push(item));
+      q._onEvict((item) => log2.push(item));
 
-      q.enqueue(1);
-      q.enqueue(2);
-      q.enqueue(3);
-      expect(q.size()).toBe(2);
+      q._enqueue(1);
+      q._enqueue(2);
+      q._enqueue(3);
+      expect(q._size()).toBe(2);
       expect(log).toEqual([1]);
       expect(log2).toEqual([1]);
 
-      q.enqueue(4);
-      expect(q.size()).toBe(2);
+      q._enqueue(4);
+      expect(q._size()).toBe(2);
       expect(log).toEqual([1, 2]);
       expect(log2).toEqual([1, 2]);
     });