Type and style improvements

Author: Anatoly Ostrovsky

@types/animations/runner/animate-runner.d.ts

@@ -36,7 +36,8 @@ export class AnimateRunner {
    * @private
    */
   private _promise;
-  _tick: (fn: any) => void;
+  /** @type {(fn: VoidFunction) => void} */
+  _tick: (fn: VoidFunction) => void;
   /**
    * Sets or replaces the current host.
    * @param {AnimationHost} host

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

@@ -24,14 +24,14 @@ export class Attributes {
    * @param {ng.ExceptionHandlerService} $exceptionHandler
    * @param {*} $sce
    * @param {import("../../shared/noderef.js").NodeRef} [nodeRef]
-   * @param {Object} [attributesToCopy]
+   * @param {Object & Record<string, any>} [attributesToCopy]
    */
   constructor(
     $animate: ng.AnimateService,
     $exceptionHandler: ng.ExceptionHandlerService,
     $sce: any,
     nodeRef?: import("../../shared/noderef.js").NodeRef,
-    attributesToCopy?: any,
+    attributesToCopy?: any & Record<string, any>,
   );
   _$animate: import("../../animations/interface.ts").AnimateService;
   _$exceptionHandler: import("../../services/exception/interface.ts").ExceptionHandler;
@@ -41,10 +41,10 @@ export class Attributes {
    * to do reverse lookup from normalized name back to actual name.
    */
   $attr: {};
-  /** @type {import("../../shared/noderef.js").NodeRef} */
-  _nodeRef: import("../../shared/noderef.js").NodeRef;
-  /** @type {Node|Element} */
-  get $$element(): Node | Element;
+  /** @type {import("../../shared/noderef.js").NodeRef | undefined} */
+  _nodeRef: import("../../shared/noderef.js").NodeRef | undefined;
+  /** @ignore @returns {Node|Element} */
+  _element(): Node | Element;
   /**
    * Converts an attribute name (e.g. dash/colon/underscore-delimited string, optionally prefixed with `x-` or
    * `data-`) to its normalized, camelCase form.

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

@@ -135,10 +135,10 @@ export class CompileProvider {
         $animate: ng.AnimateService,
       ) => (
         compileNode: string | Element | Node | ChildNode | NodeList,
-        transcludeFn?: import("./inteface.ts").TranscludeFn,
+        transcludeFn?: import("./interface.ts").TranscludeFn,
         maxPriority?: number,
         ignoreDirective?: string,
         previousCompileContext?: any,
-      ) => import("./inteface.ts").PublicLinkFn)
+      ) => import("./interface.ts").PublicLinkFn)
   )[];
 }

@types/core/compile/inteface.d.ts @types/core/compile/interface.d.ts@types/core/compile/inteface.d.ts renamed to @types/core/compile/interface.d.ts

@@ -1,5 +1,5 @@
 export type ControllerService = (
-  expression: string | Function | any[],
+  expression: string | Function | ng.AnnotatedFactory<any>,
   locals?: Record<string, any>,
   later?: boolean,
   ident?: string,

@types/core/controller/interface.d.ts

@@ -1,13 +1,3 @@
-/**
- * @param {Function} fn
- * @returns {string}
- */
-export function stringifyFn(fn: Function): string;
-/**
- * @param {Function} fn
- * @returns {Array<any>}
- */
-export function extractArgs(fn: Function): Array<any>;
 /**
  * @param {Function} func
  * @returns {boolean}

@types/core/di/di.d.ts

@@ -0,0 +1,28 @@
+import { InjectorService, ProviderInjector } from "./internal-injector.js";
+export interface StorageLike {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+}
+export interface PersistentStoreConfig {
+  backend?: StorageLike;
+  serialize?: (value: unknown) => string;
+  deserialize?: (value: string) => unknown;
+  cookie?: Record<string, unknown>;
+}
+export interface ProviderCache {
+  [key: string]: any;
+  $provide: {
+    provider: Function;
+    factory: Function;
+    service: Function;
+    value: Function;
+    constant: Function;
+    store: Function;
+    decorator: Function;
+  };
+  $injectorProvider?: {
+    $get: () => InjectorService;
+  };
+  $injector?: ProviderInjector;
+}

@types/core/di/inteface.d.ts

@@ -3,10 +3,11 @@
  */
 export class ProviderInjector extends AbstractInjector {
   /**
-   * @param {Object} cache
+   * @param {import('./interface.ts').ProviderCache} cache
    * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
    */
-  constructor(cache: any, strictDi: boolean);
+  constructor(cache: import("./interface.ts").ProviderCache, strictDi: boolean);
+  _cache: import("./interface.ts").ProviderCache;
   /**
    * Factory method for creating services.
    * @param {string} caller - The name of the caller requesting the service.
@@ -23,8 +24,12 @@ export class InjectorService extends AbstractInjector {
    * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
    */
   constructor(providerInjector: ProviderInjector, strictDi: boolean);
-  /** @type {ProviderInjector} */
-  providerInjector: ProviderInjector;
+  /** @type {(mods: Array<Function | string | ng.AnnotatedFactory<any>>) => void} */
+  loadNewModules: (
+    mods: Array<Function | string | ng.AnnotatedFactory<any>>,
+  ) => void;
+  /** @private @type {ProviderInjector} */
+  private _providerInjector;
   /**
    *
    * @param {string} name
@@ -40,13 +45,13 @@ declare class AbstractInjector {
   /**
    * @type {Object<String, Function>}
    */
-  cache: any;
+  _cache: any;
   /** @type {boolean} */
   strictDi: boolean;
   /** @type {string[]} */
-  path: string[];
+  _path: string[];
   /** @type {Object.<string, ng.NgModule>} */
-  modules: {
+  _modules: {
     [x: string]: import("./ng-module/ng-module.js").NgModule;
   };
   /**
@@ -59,38 +64,42 @@ declare class AbstractInjector {
   /**
    * Get the injection arguments for a function.
    *
-   * @param {Function|Array} fn
-   * @param {Object} locals
-   * @param {string} serviceName
+   * @param {Function|ng.AnnotatedFactory<any>} fn
+   * @param {Object & Record<string, any>} [locals]
+   * @param {string} [serviceName]
    * @returns
    */
-  injectionArgs(fn: Function | any[], locals: any, serviceName: string): any[];
+  _injectionArgs(
+    fn: Function | ng.AnnotatedFactory<any>,
+    locals?: any & Record<string, any>,
+    serviceName?: string,
+  ): any[];
   /**
    * Invoke a function with optional context and locals.
    *
-   * @param {Function|String|Array<any>} fn
+   * @param {Function|String|ng.AnnotatedFactory<any>} fn
    * @param {*} [self]
    * @param {Object} [locals]
    * @param {string} [serviceName]
    * @returns {*}
    */
   invoke(
-    fn: Function | string | Array<any>,
+    fn: Function | string | ng.AnnotatedFactory<any>,
     self?: any,
     locals?: any,
     serviceName?: string,
   ): any;
   /**
    * Instantiate a type constructor with optional locals.
-   * @param {Function|Array} type
+   * @param {Function|ng.AnnotatedFactory<any>} type
    * @param {*} [locals]
    * @param {string} [serviceName]
    */
-  instantiate(type: Function | any[], locals?: any, serviceName?: string): any;
-  /**
-   * @abstract
-   */
-  loadNewModules(): void;
+  instantiate(
+    type: Function | ng.AnnotatedFactory<any>,
+    locals?: any,
+    serviceName?: string,
+  ): any;
   /**
    * @abstract
    * @param {string} _serviceName

@types/core/di/interface.d.ts

@@ -23,20 +23,27 @@ export class NgModule {
   public name: string;
   /**
    * Array of module names that this module depends on.
+   * @ignore
    * @type {string[]}
    */
   _requires: string[];
   /**
    * Holds a collection of tasks, required to instantiate an angular component
+   * @ignore
    * @type {!Array<Array<*>>}
    */
   _invokeQueue: Array<Array<any>>;
-  /** @type {!Array<Array<*>>} */
+  /**
+   * @ignore
+   * @type {!Array<Array<*>>}
+   */
   _configBlocks: Array<Array<any>>;
-  /** @type {!Array.<ng.Injectable<any>>} */
+  /** @ignore @type {!Array.<ng.Injectable<any>>} */
   _runBlocks: Array<ng.Injectable<any>>;
-  _services: any[];
-  _restDefinitions: any[];
+  /** @ignore @type {!Array.<ng.Injectable<any>>} */
+  _services: Array<ng.Injectable<any>>;
+  /** @ignore @type {!Array.<ng.RestDefinition<any>>} */
+  _restDefinitions: Array<ng.RestDefinition<any>>;
   /**
    * @param {string} name
    * @param {any} object - Allows undefined