Type improvements

Author: tolyo

@types/angular.d.ts

@@ -3,6 +3,8 @@ export class Angular {
   private _bootsrappedModules;
   /** @public @type {ng.PubSubService} */
   public $eventBus: ng.PubSubService;
+  /** @public @type {ng.InjectorService} */
+  public $injector: ng.InjectorService;
   /**
    * @public
    * @type {string} `version` from `package.json`
@@ -129,16 +131,12 @@ export class Angular {
     config?: import("./interface.ts").AngularBootstrapConfig,
   ): ng.InjectorService;
   $rootScope: ng.Scope;
-  $injector: import("./core/di/internal-injector.js").InjectorService;
   /**
    * @param {any[]} modules
-   * @param {boolean?} strictDi
-   * @returns {import("./core/di/internal-injector.js").InjectorService}
+   * @param {boolean} [strictDi]
+   * @returns {ng.InjectorService}
    */
-  injector(
-    modules: any[],
-    strictDi: boolean | null,
-  ): import("./core/di/internal-injector.js").InjectorService;
+  injector(modules: any[], strictDi?: boolean): ng.InjectorService;
   /**
    * @param {Element|Document} element
    */
@@ -152,9 +150,9 @@ export class Angular {
    * or defined on `$scope` injectable.
    *
    * @param {string} name
-   * @returns {ProxyHandler<ng.Scope>|undefined}
+   * @returns {Proxy<ng.Scope>|undefined}
    */
-  getScopeByName(name: string): ProxyHandler<ng.Scope> | undefined;
+  getScopeByName(name: string): ProxyConstructor | undefined;
 }
 export type ModuleRegistry = {
   [x: string]: NgModule;

@types/core/compile/attributes.d.ts

@@ -59,14 +59,14 @@ export class Attributes {
    * Set a normalized attribute on the element in a way such that all directives
    * can share the attribute. This function properly handles boolean attributes.
    * @param {string} key Normalized key. (ie ngAttribute)
-   * @param {string|boolean} value The value to set. If `null` attribute will be deleted.
+   * @param {string|boolean|null} value The value to set. If `null` attribute will be deleted.
    * @param {boolean=} writeAttr If false, does not write the value to DOM element attribute.
    *     Defaults to true.
    * @param {string=} attrName Optional none normalized name. Defaults to key.
    */
   $set(
     key: string,
-    value: string | boolean,
+    value: string | boolean | null,
     writeAttr?: boolean | undefined,
     attrName?: string | undefined,
   ): void;

@types/core/scope/scope.d.ts

@@ -16,6 +16,8 @@ export function createScope(target?: any, context?: Scope): Scope;
  * @returns {boolean}
  */
 export function isNonScope(target: any): boolean;
+/** @ignore @type {Function[]}*/
+export const $postUpdateQueue: Function[];
 export class RootScopeProvider {
   rootScope: Scope;
   $get: (
@@ -176,6 +178,10 @@ export class Scope {
    * @returns {Scope|undefined}
    */
   $getById(id: string | number): Scope | undefined;
-  $searchByName(name: any): any;
+  /**
+   * @param {string} name
+   * @returns {ng.Scope|undefined}
+   */
+  $searchByName(name: string): ng.Scope | undefined;
   #private;
 }

@types/interface.d.ts

@@ -378,7 +378,7 @@ export interface DirectivePrePost {
 export type DirectiveLinkFn<T> = (
   scope: Scope,
   element: HTMLElement,
-  attrs: Attributes & Record<string, any>,
+  attrs: ng.Attributes,
   controller?: TController<T>,
   transclude?: (...args: any[]) => any,
 ) => void;

@types/namespace.d.ts

@@ -115,7 +115,7 @@ declare global {
   }
   export namespace ng {
     type Angular = TAngular;
-    type Attributes = TAttributes & Record<string, any>;
+    type Attributes = TAttributes & Record<string, string>;
     type Directive<TController = any> = TDirective<TController>;
     type DirectiveFactory = TDirectiveFactory;
     type AnnotatedDirectiveFactory = TAnnotatedDirectiveFactory;

@types/router/state/interface.d.ts

@@ -352,7 +352,7 @@ export interface StateDeclaration {
    * Note: [State] objects require unique names.
    * The name is used like an id.
    */
-  name?: string;
+  name: string;
   /**
    * Abstract state indicator
    *
@@ -807,7 +807,7 @@ export interface StateDeclaration {
  * Represents a fully built StateObject, after registration in the StateRegistry
  * and application of all StateBuilder decorators.
  */
-export interface BuiltStateDeclaration extends StateDeclaration {
+export type BuiltStateDeclaration = StateDeclaration & {
   /** Reference to the original StateDeclaration */
   self: StateDeclaration;
   /** Array of Resolvables built from the resolve / resolvePolicy */
@@ -826,7 +826,7 @@ export interface BuiltStateDeclaration extends StateDeclaration {
   parent?: BuiltStateDeclaration | null;
   /** Optional inherited data */
   data?: any;
-}
+};
 /**
  * The return type of a [[StateDeclaration.lazyLoad]] function
  *

@types/shared/strings.d.ts

@@ -15,13 +15,25 @@ export function maxLength(max: number, str: string): string;
  * If the string is already longer than the desired length, return the string.
  * Else returns the string, with extra spaces on the end, such that it reaches `length` characters.
  *
- * @param length the desired length of the string to return
- * @param str the input string
+ * @param {number} length the desired length of the string to return
+ * @param {string} str the input string
+ */
+export function padString(length: number, str: string): string;
+/**
+ * @param {string} camelCase
+ * @returns {string}
+ */
+export function kebobString(camelCase: string): string;
+/**
+ * @param {Function} fn
+ * @returns {string}
+ */
+export function functionToString(fn: Function): string;
+/**
+ * @param {[]|Function} fn
+ * @returns {string}
  */
-export function padString(length: any, str: any): any;
-export function kebobString(camelCase: any): any;
-export function functionToString(fn: any): any;
-export function fnToString(fn: any): any;
+export function fnToString(fn: [] | Function): string;
 export function stringify(value: any): any;
 /**
  * Splits on a delimiter, but returns the delimiters in the array

src/angular.js

@@ -19,6 +19,7 @@ import { unnestR } from "./shared/common.js";
 import { EventBus } from "./services/pubsub/pubsub.js";
 import { $injectTokens as $t } from "./injection-tokens.js";
 import { annotate } from "./core/di/di.js";
+import { validateIsString } from "./shared/validate.js";
 
 const ngMinErr = minErr("ng");
 
@@ -39,6 +40,9 @@ export class Angular {
     /** @public @type {ng.PubSubService} */
     this.$eventBus = EventBus;
 
+    /** @public @type {ng.InjectorService} */
+    this.$injector;
+
     /**
      * @public
      * @type {string} `version` from `package.json`
@@ -263,10 +267,15 @@ export class Angular {
             return x.$$state().resolvables;
           })
           .reduce(unnestR, [])
-          .filter((x) => {
-            return x.deps === "deferred";
-          })
+          .filter(
+            /** @param {import("./router/resolve/resolvable.js").Resolvable} x */ (
+              x,
+            ) => {
+              return x.deps === "deferred";
+            },
+          )
           .forEach(
+            /** @param {import("./router/resolve/resolvable.js").Resolvable} resolvable */
             (resolvable) =>
               (resolvable.deps = annotate(
                 resolvable.resolveFn,
@@ -281,18 +290,20 @@ export class Angular {
 
   /**
    * @param {any[]} modules
-   * @param {boolean?} strictDi
-   * @returns {import("./core/di/internal-injector.js").InjectorService}
+   * @param {boolean} [strictDi]
+   * @returns {ng.InjectorService}
    */
   injector(modules, strictDi) {
-    return createInjector(modules, strictDi);
+    this.$injector = createInjector(modules, strictDi);
+
+    return this.$injector;
   }
 
   /**
    * @param {Element|Document} element
    */
   init(element) {
-    /** @type {Element} */
+    /** @type {Element|undefined} */
     let appElement;
 
     let module;
@@ -339,10 +350,14 @@ export class Angular {
    * or defined on `$scope` injectable.
    *
    * @param {string} name
-   * @returns {ProxyHandler<ng.Scope>|undefined}
+   * @returns {Proxy<ng.Scope>|undefined}
    */
   getScopeByName(name) {
-    const scope = this.$rootScope.$searchByName(name);
+    validateIsString(name, "name");
+    /** @type {ng.RootScopeService} */
+    const $rootScope = this.$injector.get("$rootScope");
+
+    const scope = $rootScope.$searchByName(name);
 
     if (scope) {
       return scope.$proxy;

src/core/compile/attributes.js

@@ -140,7 +140,7 @@ export class Attributes {
    * Set a normalized attribute on the element in a way such that all directives
    * can share the attribute. This function properly handles boolean attributes.
    * @param {string} key Normalized key. (ie ngAttribute)
-   * @param {string|boolean} value The value to set. If `null` attribute will be deleted.
+   * @param {string|boolean|null} value The value to set. If `null` attribute will be deleted.
    * @param {boolean=} writeAttr If false, does not write the value to DOM element attribute.
    *     Defaults to true.
    * @param {string=} attrName Optional none normalized name. Defaults to key.

src/core/scope/scope.js

@@ -36,7 +36,8 @@ let $parse;
 /**@type {ng.ExceptionHandlerService} */
 let $exceptionHandler;
 
-const $postUpdateQueue = [];
+/** @ignore @type {Function[]}*/
+export const $postUpdateQueue = [];
 
 export class RootScopeProvider {
   constructor() {
@@ -1406,8 +1407,17 @@ export class Scope {
     }
   }
 
+  /**
+   * @param {string} name
+   * @returns {ng.Scope|undefined}
+   */
   $searchByName(name) {
-    const getByName = (scope, nameParam) => {
+    /**
+     * @param {ng.Scope} scope
+     * @param {string} nameParam
+     * @returns {ng.Scope|undefined}
+     */
+    function getByName(scope, nameParam) {
       if (scope.$scopename === nameParam) {
         return scope;
       } else {
@@ -1424,7 +1434,7 @@ export class Scope {
 
         return res;
       }
-    };
+    }
 
     return getByName(this.$root, name);
   }