ts

package.json

@@ -103,7 +103,8 @@
     "router_js": "^8.0.5",
     "semver": "^7.5.2",
     "silent-error": "^1.1.1",
-    "simple-html-tokenizer": "^0.5.11"
+    "simple-html-tokenizer": "^0.5.11",
+    "source-map-js": "^1.2.1"
   },
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.321.1",

packages/@ember/debug/ember-inspector-support/adapters/web-extension.ts

@@ -1,10 +1,9 @@
 import BasicAdapter from './basic';
 import { run } from '@ember/runloop';
 
-export default class extends BasicAdapter {
+export default class WebExtension extends BasicAdapter {
   private _channel!: MessageChannel;
   private _chromePort!: MessagePort;
-  private namespace: any;
   init() {
     this._channel = new MessageChannel();
     this._chromePort = this._channel?.port1;

packages/@ember/debug/ember-inspector-support/container-debug.ts

@@ -1,6 +1,7 @@
 import DebugPort from './debug-port';
 
-export default class extends DebugPort {
+export default class ContainerDebug extends DebugPort {
+  objectToConsole: any;
   get objectInspector() {
     return this.namespace?.objectInspector;
   }
@@ -19,12 +20,12 @@ export default class extends DebugPort {
   static {
     this.prototype.portNamespace = 'container';
     this.prototype.messages = {
-      getTypes() {
+      getTypes(this: ContainerDebug) {
         this.sendMessage('types', {
           types: this.getTypes(),
         });
       },
-      getInstances(message) {
+      getInstances(this: ContainerDebug, message: any) {
         let instances = this.getInstances(message.containerType);
         if (instances) {
           this.sendMessage('instances', {
@@ -37,28 +38,28 @@ export default class extends DebugPort {
           });
         }
       },
-      sendInstanceToConsole(message) {
+      sendInstanceToConsole(this: ContainerDebug, message: any) {
         const instance = this.container.lookup(message.name);
         this.objectToConsole.sendValueToConsole(instance);
       },
     };
   }
 
-  typeFromKey(key) {
-    return key.split(':').shift();
+  typeFromKey(key: string) {
+    return key.split(':').shift()!;
   }
 
-  nameFromKey(key) {
+  nameFromKey(key: string) {
     return key.split(':').pop();
   }
 
-  shouldHide(type) {
+  shouldHide(type: string) {
     return type[0] === '-' || this.TYPES_TO_SKIP.indexOf(type) !== -1;
   }
 
   instancesByType() {
     let key;
-    let instancesByType = {};
+    let instancesByType: Record<string, any> = {};
     let cache = this.container.cache;
     // Detect if InheritingDict (from Ember < 1.8)
     if (typeof cache.dict !== 'undefined' && typeof cache.eachLocal !== 'undefined') {
@@ -90,12 +91,12 @@ export default class extends DebugPort {
     return types;
   }
 
-  getInstances(type) {
+  getInstances(type: any) {
     const instances = this.instancesByType()[type];
     if (!instances) {
       return null;
     }
-    return instances.map((item) => ({
+    return instances.map((item: any) => ({
       name: this.nameFromKey(item.fullName),
       fullName: item.fullName,
       inspectable: this.objectInspector.canSend(item.instance),

packages/@ember/debug/ember-inspector-support/data-debug.ts

@@ -1,7 +1,7 @@
 import DebugPort from './debug-port';
 import { guidFor } from '@ember/debug/ember-inspector-support/utils/ember/object/internals';
 
-export default class extends DebugPort {
+export default class DataDebug extends DebugPort {
   portNamespace!: string;
   sentTypes!: Record<string, any>;
   sentRecords!: Record<string, any>;
@@ -11,8 +11,8 @@ export default class extends DebugPort {
     this.sentRecords = {};
   }
 
-  releaseTypesMethod = null;
-  releaseRecordsMethod = null;
+  releaseTypesMethod: Function | null = null;
+  releaseRecordsMethod: Function | null = null;
 
   get adapter() {
     const owner = this.namespace?.owner;
@@ -34,29 +34,27 @@ export default class extends DebugPort {
     return owner.resolveRegistration(name);
   }
 
-  get port() {
-    return this.namespace?.port;
-  }
+
   get objectInspector() {
     return this.namespace?.objectInspector;
   }
 
-  modelTypesAdded(types) {
+  modelTypesAdded(types: any[]) {
     let typesToSend;
     typesToSend = types.map((type) => this.wrapType(type));
     this.sendMessage('modelTypesAdded', {
       modelTypes: typesToSend,
     });
   }
 
-  modelTypesUpdated(types) {
+  modelTypesUpdated(types: any[]) {
     let typesToSend = types.map((type) => this.wrapType(type));
     this.sendMessage('modelTypesUpdated', {
       modelTypes: typesToSend,
     });
   }
 
-  wrapType(type) {
+  wrapType(type: any) {
     const objectId = guidFor(type.object);
     this.sentTypes[objectId] = type;
 
@@ -68,32 +66,32 @@ export default class extends DebugPort {
     };
   }
 
-  recordsAdded(recordsReceived) {
+  recordsAdded(recordsReceived: any[]) {
     let records = recordsReceived.map((record) => this.wrapRecord(record));
     this.sendMessage('recordsAdded', { records });
   }
 
-  recordsUpdated(recordsReceived) {
+  recordsUpdated(recordsReceived: any[]) {
     let records = recordsReceived.map((record) => this.wrapRecord(record));
     this.sendMessage('recordsUpdated', { records });
   }
 
-  recordsRemoved(index, count) {
+  recordsRemoved(index: number, count: number) {
     this.sendMessage('recordsRemoved', { index, count });
   }
 
-  wrapRecord(record) {
+  wrapRecord(record: any) {
     const objectId = guidFor(record.object);
-    let columnValues = {};
-    let searchKeywords = [];
+    let columnValues: Record<string, any> = {};
+    let searchKeywords: any[] = [];
     this.sentRecords[objectId] = record;
     // make objects clonable
     for (let i in record.columnValues) {
       columnValues[i] = this.objectInspector.inspect(record.columnValues[i]);
     }
     // make sure keywords can be searched and clonable
     searchKeywords = record.searchKeywords.filter(
-      (keyword) => typeof keyword === 'string' || typeof keyword === 'number'
+      (keyword: any) => typeof keyword === 'string' || typeof keyword === 'number'
     );
     return {
       columnValues,
@@ -129,28 +127,28 @@ export default class extends DebugPort {
   static {
     this.prototype.portNamespace = 'data';
     this.prototype.messages = {
-      checkAdapter() {
+      checkAdapter(this: DataDebug) {
         this.sendMessage('hasAdapter', { hasAdapter: Boolean(this.adapter) });
       },
 
-      getModelTypes() {
+      getModelTypes(this: DataDebug) {
         this.modelTypesAdded([]);
         this.releaseTypes();
         this.releaseTypesMethod = this.adapter.watchModelTypes(
-          (types) => {
+          (types: any) => {
             this.modelTypesAdded(types);
           },
-          (types) => {
+          (types: any) => {
             this.modelTypesUpdated(types);
           }
         );
       },
 
-      releaseModelTypes() {
+      releaseModelTypes(this: DataDebug) {
         this.releaseTypes();
       },
 
-      getRecords(message) {
+      getRecords(this: DataDebug, message: any) {
         const type = this.sentTypes[message.objectId];
         this.releaseRecords();
 
@@ -163,28 +161,28 @@ export default class extends DebugPort {
         this.recordsAdded([]);
         let releaseMethod = this.adapter.watchRecords(
           typeOrName,
-          (recordsReceived) => {
+          (recordsReceived: any) => {
             this.recordsAdded(recordsReceived);
           },
-          (recordsUpdated) => {
+          (recordsUpdated: any) => {
             this.recordsUpdated(recordsUpdated);
           },
-          (...args) => {
-            this.recordsRemoved(...args);
+          (index: number, count: number) => {
+            this.recordsRemoved(index, count);
           }
         );
         this.releaseRecordsMethod = releaseMethod;
       },
 
-      releaseRecords() {
+      releaseRecords(this: DataDebug) {
         this.releaseRecords();
       },
 
-      inspectModel(message) {
+      inspectModel(this: DataDebug, message: any) {
         this.objectInspector.sendObject(this.sentRecords[message.objectId].object);
       },
 
-      getFilters() {
+      getFilters(this: DataDebug) {
         this.sendMessage('filters', {
           filters: this.adapter.getFilters(),
         });

packages/@ember/debug/ember-inspector-support/debug-port.ts

@@ -1,6 +1,6 @@
 import BaseObject from '@ember/debug/ember-inspector-support/utils/base-object';
 
-export default class extends BaseObject {
+export default class DebugPort extends BaseObject {
   declare port: any;
   declare portNamespace: string;
   declare messages: Record<string, Function>;