Type improvements

Author: Anatoly Ostrovsky

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

@@ -0,0 +1,11 @@
+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>;
+}

@types/interface.d.ts

@@ -1,6 +1,9 @@
 import { Attributes } from "./core/compile/attributes.js";
 import { Scope } from "./core/scope/scope.js";
 import { NgModelController } from "./directive/model/model.js";
+export interface Constructor<T = any> {
+  new (...args: any[]): T;
+}
 export declare const PublicInjectionTokens: {
   readonly $angular: "$angular";
   readonly $attrs: "$attrs";

@types/services/storage/storage.d.ts

@@ -2,18 +2,18 @@
  * Creates a proxy that automatically persists an object's state
  * into a storage backend whenever a property is set.
  *
- * @param {object} target - The object to wrap
+ * @param {Record<PropertyKey, any>} target - The object to wrap
  * @param {string} key - The storage key
- * @param {object} storage - Any storage-like object with getItem/setItem/removeItem
+ * @param {import("../../core/di/inteface").StorageLike & import("../../core/di/inteface").PersistentStoreConfig} storage - Any storage-like object with getItem/setItem/removeItem
  * @param {{serialize?: function, deserialize?: function}} [options] - Optional custom (de)serialization
- * @returns {Proxy}
+ * @returns {Record<PropertyKey, any>}
  */
 export function createPersistentProxy(
-  target: object,
+  target: Record<PropertyKey, any>,
   key: string,
-  storage: object,
+  storage: any & any,
   options?: {
     serialize?: Function;
     deserialize?: Function;
   },
-): ProxyConstructor;
+): Record<PropertyKey, any>;

@types/shared/cache.d.ts

@@ -258,6 +258,13 @@ export function animatedomInsert(element: any, parent: any, after: any): void;
  * @returns {string} The base href.
  */
 export function getBaseHref(): string;
+/**
+ * Expando cache for adding properties to DOM nodes with JavaScript.
+ * This used to be an Object in JQLite decorator, but swapped out for a Map
+ *
+ * @type {Map<number, import('../interface.ts').ExpandoStore>}
+ */
+export const Cache: Map<number, import("../interface.ts").ExpandoStore>;
 /**
  * A list of boolean attributes in HTML.
  * @type {string[]}

@types/shared/dom.d.ts

@@ -10,7 +10,7 @@ import {
   getIsolateScope,
 } from "../../shared/dom.js";
 import { isFunction, getNodeName, extend, assert } from "../../shared/utils.js";
-import { Cache } from "../../shared/cache.js";
+import { Cache } from "../../shared/dom.js";
 import { wait } from "../../shared/test-utils.js";
 
 function isUnknownElement(el) {

src/core/compile/compile.spec.js

@@ -32,6 +32,25 @@ export function createInjector(modulesToLoad, strictDi = false) {
   /** @type {Map<String|Function, boolean>} */
   const loadedModules = new Map(); // Keep track of loaded modules to avoid circular dependencies
 
+  /**
+   * @typedef {{
+   *   $provide: {
+   *     provider: Function,
+   *     factory: Function,
+   *     service: Function,
+   *     value: Function,
+   *     constant: Function,
+   *     store: Function,
+   *     decorator: Function,
+   *   },
+   *   $injectorProvider?: {
+   *     $get: () => unknown
+   *   },
+   *   $injector?: ProviderInjector
+   * }} ProviderCache
+   */
+
+  /** @type {ProviderCache} */
   const providerCache = {
     $provide: {
       provider: supportObject(provider),
@@ -188,12 +207,11 @@ export function createInjector(modulesToLoad, strictDi = false) {
    * Registers a service persisted in a storage
    *
    * @param {string} name - Service name
-   * @param {Function} ctor - Constructor for the service
+   * @param {import("../../interface.ts").Constructor} ctor - Constructor for the service
    * @param {ng.StorageType} type - Type of storage to be instantiated
-   * @param {Storage|Object} backendOrConfig - Either a Storage-like object (getItem/setItem) or a config object
-   *                                           with { backend, serialize, deserialize }
+   * @param {import("./inteface.ts").StorageLike & import("./inteface.ts").PersistentStoreConfig} [backendOrConfig]
    */
-  function store(name, ctor, type, backendOrConfig = {}) {
+  function store(name, ctor, type, backendOrConfig) {
     return provider(name, {
       $get: /** @param {ng.InjectorService} $injector */ ($injector) => {
         switch (type) {
@@ -212,11 +230,11 @@ export function createInjector(modulesToLoad, strictDi = false) {
 
             const $cookie = $injector.get($injectTokens._cookie);
 
-            const serialize = backendOrConfig.serialize ?? JSON.stringify;
+            const serialize = backendOrConfig?.serialize ?? JSON.stringify;
 
-            const deserialize = backendOrConfig.deserialize ?? JSON.parse;
+            const deserialize = backendOrConfig?.deserialize ?? JSON.parse;
 
-            const cookieOpts = backendOrConfig.cookie ?? {};
+            const cookieOpts = backendOrConfig?.cookie ?? {};
 
             return createPersistentProxy(instance, name, {
               getItem(key) {
@@ -266,10 +284,15 @@ export function createInjector(modulesToLoad, strictDi = false) {
               backend = localStorage;
             }
 
-            return createPersistentProxy(instance, name, backend, {
-              serialize,
-              deserialize,
-            });
+            return createPersistentProxy(
+              instance,
+              name,
+              /** @type {import("./inteface.ts").StorageLike} */ (backend),
+              {
+                serialize,
+                deserialize,
+              },
+            );
           }
         }
 

src/core/di/injector.js

@@ -0,0 +1,12 @@
+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>;
+}

src/core/di/inteface.ts

@@ -2,6 +2,10 @@ import { Attributes } from "./core/compile/attributes.js";
 import { Scope } from "./core/scope/scope.js";
 import { NgModelController } from "./directive/model/model.js";
 
+export interface Constructor<T = any> {
+  new (...args: any[]): T;
+}
+
 export const PublicInjectionTokens = {
   $angular: "$angular",
   $attrs: "$attrs",

src/interface.ts

@@ -27,12 +27,18 @@ export class RouterProvider {
     /**
      * @type {Queue<import("./transition/transition.js").Transition>}
      */
-    this._transitionHistory = new Queue([], 1);
+    this._transitionHistory = new Queue(
+      /** @type {Array<import("./transition/transition.js").Transition>} */ ([]),
+      1,
+    );
 
     /**
      * @type {Queue<import("./transition/transition.js").Transition>}
      */
-    this._successfulTransitions = new Queue([], 1);
+    this._successfulTransitions = new Queue(
+      /** @type {Array<import("./transition/transition.js").Transition>} */ ([]),
+      1,
+    );
 
     /**
      * @type {import("./state/interface.ts").StateDeclaration|undefined}