fix typechecking

Author: mansona

packages/router_js/index.ts

@@ -12,11 +12,8 @@ export type { PublicTransition as Transition } from './lib/transition';
 export { default as TransitionState, TransitionError } from './lib/transition-state';
 export {
   default as InternalRouteInfo,
+  type Route,
+  type RouteInfo,
+  type RouteInfoWithAttributes,
+  type ModelFor
 } from './lib/route-info';
-
-export type {
-  Route,
-  RouteInfo,
-  RouteInfoWithAttributes,
-  ModelFor
-} from './lib/router-info';

packages/router_js/jsconfig.json

@@ -149,7 +149,7 @@ export function toReadOnlyRouteInfo<R extends Route>(
 
       get localName() {
         let parts = this.name.split('.');
-        return parts[parts.length - 1];
+        return parts[parts.length - 1]!;
       },
 
       get params() {
@@ -479,12 +479,12 @@ export class UnresolvedRouteInfoByParam<R extends Route> extends InternalRouteIn
     }
   }
 
-  getModel(transition: InternalTransition<R>): Promise<ModelFor<R> | undefined> {
+  getModel(transition: InternalTransition<R>): Promise<ModelFor<R>> {
     let fullParams = this.params;
     if (transition && transition[QUERY_PARAMS_SYMBOL]) {
       fullParams = {};
       merge(fullParams, this.params);
-      fullParams.queryParams = transition[QUERY_PARAMS_SYMBOL];
+      fullParams['queryParams'] = transition[QUERY_PARAMS_SYMBOL];
     }
 
     let route = this.route!;
@@ -552,7 +552,7 @@ export class UnresolvedRouteInfoByObject<R extends Route> extends InternalRouteI
 
     let object: Dict<unknown> = {};
     if (isParam(model)) {
-      object[paramNames[0]] = model;
+      object[paramNames[0]!] = model;
       return object;
     }
 
@@ -570,7 +570,7 @@ export class UnresolvedRouteInfoByObject<R extends Route> extends InternalRouteI
       return;
     }
 
-    let name = paramNames[0];
+    let name = paramNames[0]!;
 
     if (/_id$/.test(name)) {
       // SAFETY: Model is supposed to extend IModel already

packages/router_js/lib/route-info.ts

@@ -90,7 +90,7 @@ export default abstract class Router<R extends Route> {
   map(callback: MatchCallback) {
     this.recognizer.map(callback, function (recognizer, routes) {
       for (let i = routes.length - 1, proceed = true; i >= 0 && proceed; --i) {
-        let route = routes[i];
+        let route = routes[i]!;
         let handler = route.handler as string;
         recognizer.add(routes, { as: handler });
         proceed = route.path === '/' || route.path === '' || handler.slice(-6) === '.index';
@@ -196,7 +196,7 @@ export default abstract class Router<R extends Route> {
           localizeMapUpdates: false,
         }
       ) as RouteInfoWithAttributes[];
-      return routeInfosWithAttributes[routeInfosWithAttributes.length - 1];
+      return routeInfosWithAttributes[routeInfosWithAttributes.length - 1]!;
     });
   }
 
@@ -325,7 +325,7 @@ export default abstract class Router<R extends Route> {
       let { routeInfos } = this.state!;
       intent = new NamedTransitionIntent<R>(
         this,
-        routeInfos[routeInfos.length - 1].name,
+        routeInfos[routeInfos.length - 1]!.name,
         undefined,
         [],
         queryParams
@@ -390,11 +390,11 @@ export default abstract class Router<R extends Route> {
       log(this, transition.sequence, 'TRANSITION COMPLETE.');
 
       // Resolve with the final route.
-      return routeInfos[routeInfos.length - 1].route!;
+      return routeInfos[routeInfos.length - 1]!.route!;
     } catch (e) {
       if (!isTransitionAborted(e)) {
         let infos = transition[STATE_SYMBOL]!.routeInfos;
-        transition.trigger(true, 'error', e, transition, infos[infos.length - 1].route);
+        transition.trigger(true, 'error', e, transition, infos[infos.length - 1]!.route);
         transition.abort();
       }
 
@@ -448,7 +448,7 @@ export default abstract class Router<R extends Route> {
     let i, l, route;
 
     for (i = 0, l = partition.exited.length; i < l; i++) {
-      route = partition.exited[i].route;
+      route = partition.exited[i]!.route;
       delete route!.context;
 
       if (route !== undefined) {
@@ -468,7 +468,7 @@ export default abstract class Router<R extends Route> {
 
     try {
       for (i = 0, l = partition.reset.length; i < l; i++) {
-        route = partition.reset[i].route;
+        route = partition.reset[i]!.route;
         if (route !== undefined) {
           if (route._internalReset !== undefined) {
             route._internalReset(false, transition);
@@ -479,14 +479,14 @@ export default abstract class Router<R extends Route> {
       for (i = 0, l = partition.updatedContext.length; i < l; i++) {
         this.routeEnteredOrUpdated(
           currentRouteInfos,
-          partition.updatedContext[i],
+          partition.updatedContext[i]!,
           false,
           transition!
         );
       }
 
       for (i = 0, l = partition.entered.length; i < l; i++) {
-        this.routeEnteredOrUpdated(currentRouteInfos, partition.entered[i], true, transition!);
+        this.routeEnteredOrUpdated(currentRouteInfos, partition.entered[i]!, true, transition!);
       }
     } catch (e) {
       this.state = oldState;
@@ -631,8 +631,8 @@ export default abstract class Router<R extends Route> {
       l;
 
     for (i = 0, l = newRouteInfos.length; i < l; i++) {
-      let oldRouteInfo = oldRouteInfos[i],
-        newRouteInfo = newRouteInfos[i];
+      let oldRouteInfo = oldRouteInfos[i]!,
+        newRouteInfo = newRouteInfos[i]!;
 
       if (!oldRouteInfo || oldRouteInfo.route !== newRouteInfo.route) {
         routeChanged = true;
@@ -652,7 +652,7 @@ export default abstract class Router<R extends Route> {
     }
 
     for (i = newRouteInfos.length, l = oldRouteInfos.length; i < l; i++) {
-      routes.exited.unshift(oldRouteInfos[i]);
+      routes.exited.unshift(oldRouteInfos[i]!);
     }
 
     routes.reset = routes.updatedContext.slice();
@@ -669,19 +669,19 @@ export default abstract class Router<R extends Route> {
     }
 
     let { routeInfos } = state;
-    let { name: routeName } = routeInfos[routeInfos.length - 1];
+    let { name: routeName } = routeInfos[routeInfos.length - 1]!;
     let params: Dict<unknown> = {};
 
     for (let i = routeInfos.length - 1; i >= 0; --i) {
-      let routeInfo = routeInfos[i];
+      let routeInfo = routeInfos[i]!;
       merge(params, routeInfo.params);
       if (routeInfo.route!.inaccessibleByURL) {
         urlMethod = null;
       }
     }
 
     if (urlMethod) {
-      params.queryParams = transition._visibleQueryParams || state.queryParams;
+      params['queryParams'] = transition._visibleQueryParams || state.queryParams;
       let url = this.recognizer.generate(routeName, params as Params);
 
       // transitions during the initial transition must always use replaceURL.
@@ -761,7 +761,7 @@ export default abstract class Router<R extends Route> {
 
     let finalQueryParams: Dict<unknown> = {};
     for (let i = 0, len = finalQueryParamsArray.length; i < len; ++i) {
-      let qp = finalQueryParamsArray[i];
+      let qp = finalQueryParamsArray[i]!;
       finalQueryParams[qp.key] = qp.value;
       if (transition && qp.visible !== false) {
         transition._visibleQueryParams[qp.key] = qp.value;
@@ -798,7 +798,7 @@ export default abstract class Router<R extends Route> {
         Object.assign({}, newTransition[QUERY_PARAMS_SYMBOL]),
         { includeAttributes, localizeMapUpdates: false }
       );
-      newTransition!.to = toInfos[toInfos.length - 1] || null;
+      newTransition!.to = toInfos[toInfos.length - 1]! || null;
     }
   }
 
@@ -815,7 +815,7 @@ export default abstract class Router<R extends Route> {
 
     oldRouteInfoLen = oldRouteInfos.length;
     for (i = 0; i < oldRouteInfoLen; i++) {
-      oldHandler = oldRouteInfos[i];
+      oldHandler = oldRouteInfos[i]!;
       newRouteInfo = newState.routeInfos[i];
 
       if (!newRouteInfo || oldHandler.name !== newRouteInfo.name) {
@@ -904,11 +904,11 @@ export default abstract class Router<R extends Route> {
     let routeInfos = state!.routeInfos;
 
     if (pivotRoute === undefined) {
-      pivotRoute = routeInfos[0].route;
+      pivotRoute = routeInfos[0]!.route;
     }
 
     log(this, 'Starting a refresh transition');
-    let name = routeInfos[routeInfos.length - 1].name;
+    let name = routeInfos[routeInfos.length - 1]!.name;
     let intent = new NamedTransitionIntent(
       this,
       name,
@@ -961,7 +961,7 @@ export default abstract class Router<R extends Route> {
 
     let params: Params = {};
     for (let i = 0, len = state.routeInfos.length; i < len; ++i) {
-      let routeInfo = state.routeInfos[i];
+      let routeInfo = state.routeInfos[i]!;
       let routeParams = routeInfo.serialize();
       merge(params, routeParams);
     }
@@ -993,12 +993,12 @@ export default abstract class Router<R extends Route> {
       return false;
     }
 
-    let targetHandler = targetRouteInfos[targetRouteInfos.length - 1].name;
+    let targetHandler = targetRouteInfos[targetRouteInfos.length - 1]!.name;
     let recognizerHandlers: ParsedHandler[] = this.recognizer.handlersFor(targetHandler);
 
     let index = 0;
     for (len = recognizerHandlers.length; index < len; ++index) {
-      routeInfo = targetRouteInfos[index];
+      routeInfo = targetRouteInfos[index]!;
       if (routeInfo.name === routeName) {
         break;
       }
@@ -1072,11 +1072,11 @@ function routeInfosSameExceptQueryParams<R1 extends Route, R2 extends Route>(
   }
 
   for (let i = 0, len = routeInfos.length; i < len; ++i) {
-    if (routeInfos[i].name !== otherRouteInfos[i].name) {
+    if (routeInfos[i]!.name !== otherRouteInfos[i]!.name) {
       return false;
     }
 
-    if (!paramsEqual(routeInfos[i].params, otherRouteInfos[i].params)) {
+    if (!paramsEqual(routeInfos[i]!.params, otherRouteInfos[i]!.params)) {
       return false;
     }
   }
@@ -1102,7 +1102,7 @@ function paramsEqual(params: Dict<unknown> | undefined, otherParams: Dict<unknow
   }
 
   for (let i = 0, len = keys.length; i < len; ++i) {
-    let key = keys[i];
+    let key = keys[i]!;
 
     if (params[key] !== otherParams[key]) {
       return false;

packages/router_js/lib/router.ts

@@ -36,7 +36,7 @@ export default class NamedTransitionIntent<R extends Route> extends TransitionIn
   applyToState(oldState: TransitionState<R>, isIntermediate: boolean): TransitionState<R> {
     let handlers: ParsedHandler[] = this.router.recognizer.handlersFor(this.name);
 
-    let targetRouteName = handlers[handlers.length - 1].handler;
+    let targetRouteName = handlers[handlers.length - 1]!.handler;
 
     return this.applyToHandlers(oldState, handlers, targetRouteName, isIntermediate, false);
   }
@@ -57,18 +57,18 @@ export default class NamedTransitionIntent<R extends Route> extends TransitionIn
     // Pivot handlers are provided for refresh transitions
     if (this.pivotHandler) {
       for (i = 0, len = parsedHandlers.length; i < len; ++i) {
-        if (parsedHandlers[i].handler === this.pivotHandler._internalName) {
+        if (parsedHandlers[i]!.handler === this.pivotHandler._internalName) {
           invalidateIndex = i;
           break;
         }
       }
     }
 
     for (i = parsedHandlers.length - 1; i >= 0; --i) {
-      let result = parsedHandlers[i];
+      let result = parsedHandlers[i]!;
       let name = result.handler;
 
-      let oldHandlerInfo = oldState.routeInfos[i];
+      let oldHandlerInfo = oldState.routeInfos[i]!;
       let newHandlerInfo:
         | InternalRouteInfo<R>
         | UnresolvedRouteInfoByObject<R>
@@ -161,9 +161,9 @@ export default class NamedTransitionIntent<R extends Route> extends TransitionIn
 
   invalidateChildren(handlerInfos: InternalRouteInfo<R>[], invalidateIndex: number) {
     for (let i = invalidateIndex, l = handlerInfos.length; i < l; ++i) {
-      let handlerInfo = handlerInfos[i];
+      let handlerInfo = handlerInfos[i]!;
       if (handlerInfo.isResolved) {
-        let { name, params, route, paramNames } = handlerInfos[i];
+        let { name, params, route, paramNames } = handlerInfos[i]!;
         handlerInfos[i] = new UnresolvedRouteInfoByParam(
           this.router,
           name,
@@ -233,7 +233,7 @@ export default class NamedTransitionIntent<R extends Route> extends TransitionIn
         (oldHandlerInfo && name === oldHandlerInfo.name && oldHandlerInfo.params) || {};
 
       let peek = objects[objects.length - 1];
-      let paramName = names[numNames];
+      let paramName = names[numNames]!;
       if (isParam(peek)) {
         params[paramName] = '' + objects.pop();
       } else {

packages/router_js/lib/transition-intent/named-transition-intent.ts

@@ -64,7 +64,7 @@ export default class URLTransitionIntent<R extends Route> extends TransitionInte
         newRouteInfo.routePromise = newRouteInfo.routePromise.then(checkHandlerAccessibility);
       }
 
-      let oldRouteInfo = oldState.routeInfos[i];
+      let oldRouteInfo = oldState.routeInfos[i]!;
       if (statesDiffer || newRouteInfo.shouldSupersede(oldRouteInfo)) {
         statesDiffer = true;
         newState.routeInfos[i] = newRouteInfo;

packages/router_js/lib/transition-intent/url-transition-intent.ts

@@ -24,7 +24,7 @@ function handleError<R extends Route>(
 
   throw new TransitionError(
     error,
-    currentState.routeInfos[errorHandlerIndex].route!,
+    currentState.routeInfos[errorHandlerIndex]!.route!,
     wasAborted,
     currentState
   );
@@ -40,7 +40,7 @@ function resolveOneRouteInfo<R extends Route>(
     return;
   }
 
-  let routeInfo = currentState.routeInfos[transition.resolveIndex];
+  let routeInfo = currentState.routeInfos[transition.resolveIndex]!;
 
   let callback = proceed.bind(null, currentState, transition) as (
     resolvedRouteInfo: ResolvedRouteInfo<R>
@@ -54,7 +54,7 @@ function proceed<R extends Route>(
   transition: Transition<R>,
   resolvedRouteInfo: ResolvedRouteInfo<R>
 ): void | Promise<void> {
-  let wasAlreadyResolved = currentState.routeInfos[transition.resolveIndex].isResolved;
+  let wasAlreadyResolved = currentState.routeInfos[transition.resolveIndex]!.isResolved;
 
   // Swap the previously unresolved routeInfo with
   // the resolved routeInfo

packages/router_js/lib/transition-state.ts

@@ -163,11 +163,11 @@ export default class Transition<R extends Route> implements Partial<Promise<R>>
 
       let len = state.routeInfos.length;
       if (len) {
-        this.targetName = state.routeInfos[len - 1].name;
+        this.targetName = state.routeInfos[len - 1]!.name;
       }
 
       for (let i = 0; i < len; ++i) {
-        let handlerInfo = state.routeInfos[i];
+        let handlerInfo = state.routeInfos[i]!;
 
         // TODO: this all seems hacky
         if (!handlerInfo.isResolved) {
@@ -268,6 +268,7 @@ export default class Transition<R extends Route> implements Partial<Promise<R>>
     @public
    */
   finally<T>(callback?: T | undefined, label?: string) {
+    // @ts-expect-error @types/rsvp doesn't have the correct signiture for RSVP.Promise.finally
     return this.promise!.finally(callback, label);
   }
 

packages/router_js/lib/transition.ts

@@ -16,7 +16,9 @@ const UnrecognizedURLError: UnrecognizedURLConstructor = (function () {
     this.name = 'UnrecognizedURLError';
     this.message = message || 'UnrecognizedURL';
 
+    // @ts-expect-error I don't know why this is failing
     if (Error.captureStackTrace) {
+      // @ts-expect-error I don't know why this is failing
       Error.captureStackTrace(this, UnrecognizedURLError);
     } else {
       this.stack = error.stack;

packages/router_js/lib/unrecognized-url-error.ts

@@ -103,7 +103,7 @@ export function isParam(object: any): object is string | number {
 }
 
 export function forEach<T>(array: T[], callback: (item: T) => boolean) {
-  for (let i = 0, l = array.length; i < l && callback(array[i]) !== false; i++) {
+  for (let i = 0, l = array.length; i < l && callback(array[i]!) !== false; i++) {
     // empty intentionally
   }
 }