Merge pull request #20065 from wagenet/more-internals-ts2

Convert more internals to TS

Author: wagenet

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

@@ -857,7 +857,7 @@ class Component
       if (!lazyEventsProcessedForComponentClass.has(proto)) {
         let lazyEvents = eventDispatcher.lazyEvents;
 
-        lazyEvents.forEach((mappedEventName: string | null, event: string) => {
+        lazyEvents.forEach((mappedEventName, event) => {
           if (mappedEventName !== null && typeof (this as any)[mappedEventName] === 'function') {
             eventDispatcher.setupHandlerForBrowserEvent(event);
           }

packages/@ember/-internals/glimmer/lib/renderer.ts

@@ -86,6 +86,8 @@ export class DynamicScope implements GlimmerDynamicScope {
   }
 }
 
+const NO_OP = () => {};
+
 // This wrapper logic prevents us from rerendering in case of a hard failure
 // during render. This prevents infinite revalidation type loops from occuring,
 // and ensures that errors are not swallowed by subsequent follow on failures.
@@ -218,10 +220,6 @@ function loopBegin(): void {
   }
 }
 
-function K() {
-  /* noop */
-}
-
 let renderSettledDeferred: RSVP.Deferred<void> | null = null;
 /*
   Returns a promise which will resolve when rendering has settled. Settled in
@@ -239,7 +237,7 @@ export function renderSettled() {
     // a chance to resolve (because its resolved in backburner's "end" event)
     if (!_getCurrentRunLoop()) {
       // ensure a runloop has been kicked off
-      _backburner.schedule('actions', null, K);
+      _backburner.schedule('actions', null, NO_OP);
     }
   }
 
@@ -266,7 +264,7 @@ function loopEnd() {
         throw new Error('infinite rendering invalidation detected');
       }
       loops++;
-      return _backburner.join(null, K);
+      return _backburner.join(null, NO_OP);
     }
   }
   loops = 0;

packages/@ember/-internals/metal/lib/computed.ts

@@ -903,8 +903,8 @@ export function computed(
 }
 
 export function autoComputed(
-  ...config: [ComputedPropertyObj]
-): ComputedDecorator | DecoratorPropertyDescriptor {
+  ...config: [ComputedPropertyObj | ComputedPropertyGetterFunction]
+): ComputedDecorator {
   // SAFETY: We passed in the impl for this class
   return makeComputedDecorator(
     new AutoComputedProperty(config),

packages/@ember/-internals/runtime/lib/mixins/array.d.ts

@@ -26,27 +26,27 @@ interface EmberArray<T> extends Enumerable {
   ): NativeArray<U>;
   mapBy<K extends string>(key: K): NativeArray<Value<T, K>>;
   filter<Target>(
-    callback: (this: Target, item: T, index: number, arr: this) => boolean,
+    callback: (this: Target, item: T, index: number, arr: this) => unknown,
     target?: Target
   ): NativeArray<T>;
   reject<Target>(
-    callback: (this: Target, item: T, index: number, arr: this) => boolean,
+    callback: (this: Target, item: T, index: number, arr: this) => unknown,
     target?: Target
   ): NativeArray<T>;
   filterBy(key: string): NativeArray<T>;
   rejectBy(key: string): NativeArray<T>;
   find<Target = void>(
-    callback: (this: Target, item: T, index: number, arr: this) => boolean,
+    callback: (this: Target, item: T, index: number, arr: this) => unknown,
     target?: Target
   ): T | undefined;
   findBy<K extends string>(key: K, value?: Value<T, K>): T | undefined;
   every<Target = void>(
-    callback: (this: Target, item: T, index: number, arr: this) => boolean,
+    callback: (this: Target, item: T, index: number, arr: this) => unknown,
     target?: Target
   ): boolean;
   isEvery<K extends string>(key: K, value?: Value<T, K>): boolean;
   any<Target = void>(
-    callback: (this: Target, item: T, index: number, arr: this) => boolean,
+    callback: (this: Target, item: T, index: number, arr: this) => unknown,
     target?: Target
   ): boolean;
   isAny<K extends string>(key: K, value?: Value<T, K>): boolean;
@@ -103,5 +103,8 @@ export function A<A>(arr: A): A extends Array<infer V> ? NativeArray<V> : Native
 export function A<T>(): NativeArray<T>;
 
 export function removeAt<T>(array: T[] | EmberArray<T>, start: number, len: number): EmberArray<T>;
-export function uniqBy<T>(array: T[], keyOrFunc: string | ((item: T) => unknown)): T[];
+export function uniqBy<T>(
+  array: T[] | EmberArray<T>,
+  keyOrFunc: string | ((item: T) => unknown)
+): T[] | EmberArray<T>;
 export function isArray(obj: unknown): boolean;

packages/@ember/controller/lib/controller_mixin.d.ts

@@ -1,6 +1,12 @@
 import { Mixin, computed } from '@ember/-internals/metal';
+import { RouteArgs } from '@ember/-internals/routing/lib/utils';
 import { ActionHandler } from '@ember/-internals/runtime';
 import { symbol } from '@ember/-internals/utils';
+import Route from '@ember/routing/route';
+import { Transition } from 'router_js';
+
+export type ControllerQueryParamType = 'boolean' | 'number' | 'array' | 'string';
+export type ControllerQueryParam = string | Record<string, { type: ControllerQueryParamType }>;
 
 const MODEL = symbol('MODEL');
 
@@ -14,7 +20,23 @@ const MODEL = symbol('MODEL');
   @uses Ember.ActionHandler
   @private
 */
-export default Mixin.create(ActionHandler, {
+interface ControllerMixin<T> extends ActionHandler {
+  /** @internal */
+  _qpDelegate: unknown | null;
+
+  isController: true;
+  target: unknown | null;
+  model: T;
+
+  // From routing/lib/ext/controller
+
+  queryParams: Array<ControllerQueryParam>;
+
+  transitionToRoute(...args: RouteArgs<Route>): Transition;
+
+  replaceRoute(...args: RouteArgs<Route>): Transition;
+}
+const ControllerMixin = Mixin.create(ActionHandler, {
   /* ducktype as a controller */
   isController: true,
 
@@ -50,8 +72,10 @@ export default Mixin.create(ActionHandler, {
       return this[MODEL];
     },
 
-    set(key, value) {
+    set(_key, value) {
       return (this[MODEL] = value);
     },
   }),
 });
+
+export default ControllerMixin;