Merge pull request #19940 from wagenet/routing-types

Future public @ember/routing types

Author: wagenet

package.json

@@ -140,7 +140,7 @@
     "rollup-plugin-commonjs": "^9.3.4",
     "rollup-plugin-node-resolve": "^4.2.4",
     "route-recognizer": "^0.3.4",
-    "router_js": "^7.3.0",
+    "router_js": "^8.0.1",
     "rsvp": "^4.8.5",
     "serve-static": "^1.14.1",
     "simple-dom": "^1.4.0",

packages/@ember/-internals/container/lib/container.ts

@@ -407,9 +407,9 @@ function destroyDestroyables(container: Container): void {
   let cache = container.cache;
   let keys = Object.keys(cache);
 
-  for (let i = 0; i < keys.length; i++) {
-    let key = keys[i];
+  for (let key of keys) {
     let value = cache[key];
+    assert('has cached value', value);
 
     if (value.destroy) {
       value.destroy();

packages/@ember/-internals/container/lib/registry.ts

@@ -28,8 +28,8 @@ export interface IRegistry {
     fullName: string,
     optionName: K
   ): TypeOptions[K] | undefined;
-  getOptions(fullName: string): TypeOptions;
-  getOptionsForType(type: string): TypeOptions;
+  getOptions(fullName: string): TypeOptions | undefined;
+  getOptionsForType(type: string): TypeOptions | undefined;
   knownForType(type: string): KnownForTypeResult;
   makeToString<T, C>(factory: Factory<T, C>, fullName: string): string;
   normalizeFullName(fullName: string): string;
@@ -396,7 +396,7 @@ export default class Registry implements IRegistry {
     this._typeOptions[type] = options;
   }
 
-  getOptionsForType(type: string): TypeOptions {
+  getOptionsForType(type: string): TypeOptions | undefined {
     let optionsForType = this._typeOptions[type];
     if (optionsForType === undefined && this.fallback !== null) {
       optionsForType = this.fallback.getOptionsForType(type);
@@ -415,7 +415,7 @@ export default class Registry implements IRegistry {
     this._options[normalizedName] = options;
   }
 
-  getOptions(fullName: string): TypeOptions {
+  getOptions(fullName: string): TypeOptions | undefined {
     let normalizedName = this.normalize(fullName);
     let options = this._options[normalizedName];
 
@@ -436,6 +436,7 @@ export default class Registry implements IRegistry {
     }
 
     let type = fullName.split(':')[0];
+    assert('has type', type); // split always will have at least one value
     options = this._typeOptions[type];
 
     if (options && options[optionName] !== undefined) {
@@ -484,8 +485,7 @@ export default class Registry implements IRegistry {
   knownForType(type: string): KnownForTypeResult {
     let localKnown = dictionary(null);
     let registeredNames = Object.keys(this.registrations);
-    for (let index = 0; index < registeredNames.length; index++) {
-      let fullName = registeredNames[index];
+    for (let fullName of registeredNames) {
       let itemType = fullName.split(':')[0];
 
       if (itemType === type) {
@@ -522,7 +522,9 @@ if (DEBUG) {
 
     for (let key in hash) {
       if (Object.prototype.hasOwnProperty.call(hash, key)) {
-        let { specifier } = hash[key];
+        let value = hash[key];
+        assert('has value', value);
+        let { specifier } = value;
         assert(
           `Expected a proper full name, given '${specifier}'`,
           this.isValidFullName(specifier)
@@ -543,9 +545,8 @@ if (DEBUG) {
       return;
     }
 
-    for (let i = 0; i < injections.length; i++) {
-      let { specifier } = injections[i];
-
+    for (let injection of injections) {
+      let { specifier } = injection;
       assert(`Attempting to inject an unknown injection: '${specifier}'`, this.has(specifier));
     }
   };
@@ -589,6 +590,8 @@ const privateNames: { [key: string]: string } = dictionary(null);
 const privateSuffix = `${Math.random()}${Date.now()}`.replace('.', '');
 
 export function privatize([fullName]: TemplateStringsArray): string {
+  assert('has a single string argument', arguments.length === 1 && fullName);
+
   let name = privateNames[fullName];
   if (name) {
     return name;

packages/@ember/-internals/glimmer/lib/component-managers/curly.ts

@@ -85,6 +85,7 @@ function applyAttributeBindings(
 
   while (i !== -1) {
     let binding = attributeBindings[i];
+    assert('has binding', binding);
     let parsed: [string, string, boolean] = parseAttributeBinding(binding);
     let attribute = parsed[1];
 
@@ -174,6 +175,7 @@ export default class CurlyComponentManager
       );
 
       let { __ARGS__, ...rest } = args.named.capture();
+      assert('[BUG] unexpectedly missing __ARGS__ after check', __ARGS__);
 
       // does this need to be untracked?
       let __args__ = valueForRef(__ARGS__) as CapturedArguments;
@@ -215,14 +217,8 @@ export default class CurlyComponentManager
       Object.assign(named, args.named.capture());
 
       for (let i = 0; i < count; i++) {
-        // As of TS 3.7, tsc is giving us the following error on this line without the type annotation
-        //
-        //   TS7022: 'name' implicitly has type 'any' because it does not have a type annotation and is
-        //   referenced directly or indirectly in its own initializer.
-        //
-        // This is almost certainly a TypeScript bug, feel free to try and remove the annotation after
-        // upgrading if it is not needed anymore.
-        const name: string = positionalParams[i];
+        let name = positionalParams[i];
+        assert('Expected at least one positional param', name);
 
         assert(
           `You cannot specify both a positional param (at position ${i}) and the hash argument \`${name}\`.`,
@@ -495,8 +491,7 @@ export function processComponentInitializationAssertions(component: Component, p
     `classNameBindings must not have spaces in them: ${component}`,
     (() => {
       let { classNameBindings } = component;
-      for (let i = 0; i < classNameBindings.length; i++) {
-        let binding = classNameBindings[i];
+      for (let binding of classNameBindings) {
         if (binding.split(' ').length > 1) {
           return false;
         }

packages/@ember/-internals/glimmer/lib/components/link-to.ts

@@ -1,5 +1,5 @@
 import { Owner } from '@ember/-internals/owner';
-import { RouterState, RoutingService } from '@ember/-internals/routing';
+import { Route, RouterState, RoutingService } from '@ember/-internals/routing';
 import { isSimpleClick } from '@ember/-internals/views';
 import { assert, debugFreeze, inspect, warn } from '@ember/debug';
 import { EngineInstance, getEngineParent } from '@ember/engine';
@@ -274,7 +274,7 @@ class LinkTo extends InternalComponent {
     return 'LinkTo';
   }
 
-  @service('-routing') private declare routing: RoutingService;
+  @service('-routing') private declare routing: RoutingService<Route>;
 
   validateArguments(): void {
     assert(
@@ -466,12 +466,12 @@ class LinkTo extends InternalComponent {
   }
 
   private get isActive(): boolean {
-    return this.isActiveForState(this.routing.currentState as Maybe<RouterState>);
+    return this.isActiveForState(this.routing.currentState as Maybe<RouterState<Route>>);
   }
 
   private get willBeActive(): Option<boolean> {
-    let current = this.routing.currentState as Maybe<RouterState>;
-    let target = this.routing.targetState as Maybe<RouterState>;
+    let current = this.routing.currentState as Maybe<RouterState<Route>>;
+    let target = this.routing.targetState as Maybe<RouterState<Route>>;
 
     if (current === target) {
       return null;
@@ -525,7 +525,7 @@ class LinkTo extends InternalComponent {
     }
   }
 
-  private isActiveForState(state: Maybe<RouterState>): boolean {
+  private isActiveForState(state: Maybe<RouterState<Route>>): boolean {
     if (!isPresent(state)) {
       return false;
     }

packages/@ember/-internals/glimmer/lib/helpers/-disallow-dynamic-resolution.ts

@@ -7,21 +7,21 @@ import { createComputeRef, valueForRef } from '@glimmer/reference';
 import { internalHelper } from './internal-helper';
 
 export default internalHelper(({ positional, named }: CapturedArguments) => {
+  const nameOrValueRef = positional[0];
+
   assert(
     `[BUG] wrong number of positional arguments, expecting 1, got ${positional.length}`,
-    positional.length === 1
+    positional.length === 1 && nameOrValueRef
   );
 
-  let nameOrValueRef = positional[0];
-
-  assert(`[BUG] expecting \`type\` named argument`, 'type' in named);
-  assert(`[BUG] expecting \`loc\` named argument`, 'loc' in named);
-  assert(`[BUG] expecting \`original\` named argument`, 'original' in named);
-
   let typeRef = named.type;
   let locRef = named.loc;
   let originalRef = named.original;
 
+  assert(`[BUG] expecting \`type\` named argument`, typeRef);
+  assert(`[BUG] expecting \`loc\` named argument`, locRef);
+  assert(`[BUG] expecting \`original\` named argument`, originalRef);
+
   // Bug: why do these fail?
   // assert('[BUG] expecting a string literal for the `type` argument', isConstRef(typeRef));
   // assert('[BUG] expecting a string literal for the `loc` argument', isConstRef(locRef));

packages/@ember/-internals/glimmer/lib/helpers/-in-element-null-check.ts

@@ -8,7 +8,8 @@ let helper: Helper;
 
 if (DEBUG) {
   helper = (args: CapturedArguments) => {
-    let inner = args.positional[0];
+    const inner = args.positional[0];
+    assert('expected at least one positional arg', inner);
 
     return createComputeRef(() => {
       let value = valueForRef(inner);
@@ -22,7 +23,11 @@ if (DEBUG) {
     });
   };
 } else {
-  helper = (args: CapturedArguments) => args.positional[0];
+  helper = (args: CapturedArguments) => {
+    let arg = args.positional[0];
+    assert('expected at least one positional arg', arg);
+    return arg;
+  };
 }
 
 export default internalHelper(helper);

packages/@ember/-internals/glimmer/lib/helpers/-normalize-class.ts

@@ -1,13 +1,19 @@
+import { assert } from '@ember/debug';
 import { dasherize } from '@ember/string';
 import { CapturedArguments } from '@glimmer/interfaces';
 import { createComputeRef, valueForRef } from '@glimmer/reference';
 import { internalHelper } from './internal-helper';
 
 export default internalHelper(({ positional }: CapturedArguments) => {
   return createComputeRef(() => {
-    let classNameParts = (valueForRef(positional[0]) as string).split('.');
+    let classNameArg = positional[0];
+    let valueArg = positional[1];
+    assert('expected at least two positional args', classNameArg && valueArg);
+
+    let classNameParts = (valueForRef(classNameArg) as string).split('.');
     let className = classNameParts[classNameParts.length - 1];
-    let value = valueForRef(positional[1]);
+    assert('has className', className); // Always at least one split result
+    let value = valueForRef(valueArg);
 
     if (value === true) {
       return dasherize(className);

packages/@ember/-internals/glimmer/lib/helpers/-resolve.ts

@@ -19,7 +19,7 @@ export default internalHelper(({ positional }: CapturedArguments, owner: Owner |
 
   let fullNameRef = positional[0];
 
-  assert('[BUG] expecting a string literal as argument', isConstRef(fullNameRef));
+  assert('[BUG] expecting a string literal as argument', fullNameRef && isConstRef(fullNameRef));
 
   let fullName = valueForRef(fullNameRef);
 

packages/@ember/-internals/glimmer/lib/helpers/-track-array.ts

@@ -3,6 +3,7 @@
 */
 import { tagForProperty } from '@ember/-internals/metal';
 import { isObject } from '@ember/-internals/utils';
+import { assert } from '@ember/debug';
 import { CapturedArguments } from '@glimmer/interfaces';
 import { createComputeRef, valueForRef } from '@glimmer/reference';
 import { consumeTag } from '@glimmer/validator';
@@ -14,7 +15,8 @@ import { internalHelper } from './internal-helper';
   transform at build time, similar to the (-each-in) helper
 */
 export default internalHelper(({ positional }: CapturedArguments) => {
-  let inner = positional[0];
+  const inner = positional[0];
+  assert('expected at least one positional arg', inner);
 
   return createComputeRef(() => {
     let iterable = valueForRef(inner);