ember-inspector 4.13.1-alpha.2025.7.29 → 4.13.1-alpha.2025.7.30

package/ember_debug/lib/start-inspector.js

@@ -0,0 +1,211 @@
+/* eslint-disable ember/new-module-imports, ember/no-test-import-export */
+
+import versionTest from './version-test';
+import { EMBER_VERSIONS_SUPPORTED } from './versions';
+import sendApps from './send-apps';
+import getApplications from './get-applications';
+import bootEmberInspector from './boot-ember-inspector';
+import setupInstanceInitializer from './setup-instance-initializer';
+import sendVersionMiss from './send-version-miss';
+
+let Ember;
+
+function onReady(callback) {
+  if (
+    document.readyState === 'complete' ||
+    document.readyState === 'interactive'
+  ) {
+    setTimeout(completed);
+  } else {
+    document.addEventListener('DOMContentLoaded', completed, false);
+    // For some reason DOMContentLoaded doesn't always work
+    window.addEventListener('load', completed, false);
+  }
+
+  function completed() {
+    document.removeEventListener('DOMContentLoaded', completed, false);
+    window.removeEventListener('load', completed, false);
+    callback();
+  }
+}
+
+export function onEmberReady(callback) {
+  var triggered = false;
+  var triggerOnce = function () {
+    if (triggered) {
+      return;
+    }
+
+    if (!Ember) {
+      try {
+        Ember = requireModule('ember/barrel')['default'];
+      } catch {
+        // noop
+      }
+      try {
+        Ember = Ember || requireModule('ember')['default'];
+      } catch {
+        Ember = window.Ember;
+      }
+    }
+
+    if (!Ember) {
+      return;
+    }
+    // `Ember.Application` load hook triggers before all of Ember is ready.
+    // In this case we ignore and wait for the `Ember` load hook.
+    if (!Ember.RSVP) {
+      return;
+    }
+    triggered = true;
+    callback();
+  };
+
+  // Newest Ember versions >= 1.10
+
+  const later = () => setTimeout(triggerOnce, 0);
+  window.addEventListener('Ember', later, { once: true });
+  // Oldest Ember versions or if this was injected after Ember has loaded.
+  onReady(triggerOnce);
+}
+
+export function startInspector(adapter) {
+  // There's probably a better way
+  // to determine when the application starts
+  // but this definitely works
+  function onApplicationStart(callback) {
+    if (typeof Ember === 'undefined') {
+      return;
+    }
+
+    const adapterInstance = new adapter();
+
+    adapterInstance.onMessageReceived(function (message) {
+      if (message.type === 'app-picker-loaded') {
+        sendApps(adapterInstance, getApplications(Ember));
+      }
+
+      if (message.type === 'app-selected') {
+        let current = window.EmberInspector._application;
+        let selected = getApplications(Ember).find(
+          (app) => Ember.guidFor(app) === message.applicationId,
+        );
+
+        if (
+          selected &&
+          current !== selected &&
+          selected.__deprecatedInstance__
+        ) {
+          bootEmberInspector(selected.__deprecatedInstance__);
+        }
+      }
+    });
+
+    var apps = getApplications(Ember);
+
+    sendApps(adapterInstance, apps);
+
+    function loadInstance(app) {
+      const applicationInstances = app._applicationInstances && [
+        ...app._applicationInstances,
+      ];
+      let instance = app.__deprecatedInstance__ || applicationInstances[0];
+      if (instance) {
+        // App started
+        setupInstanceInitializer(Ember, app, callback);
+        callback(instance);
+        return true;
+      }
+    }
+
+    var app;
+    for (var i = 0, l = apps.length; i < l; i++) {
+      app = apps[i];
+      // We check for the existance of an application instance because
+      // in Ember > 3 tests don't destroy the app when they're done but the app has no booted instances.
+      if (app._readinessDeferrals === 0) {
+        if (loadInstance(app)) {
+          break;
+        }
+      }
+
+      // app already run initializers, but no instance, use _bootPromise and didBecomeReady
+      if (app._bootPromise) {
+        app._bootPromise.then((app) => {
+          loadInstance(app);
+        });
+      }
+
+      app.reopen({
+        didBecomeReady() {
+          this._super.apply(this, arguments);
+          setTimeout(() => loadInstance(app), 0);
+        },
+      });
+    }
+    Ember.Application.initializer({
+      name: 'ember-inspector-booted',
+      initialize: function (app) {
+        setupInstanceInitializer(app, callback);
+      },
+    });
+  }
+
+  return async function startInspector() {
+    // global to prevent injection
+    if (window.NO_EMBER_DEBUG) {
+      return;
+    }
+
+    // If Ember doesn't exist, we should stop here to avoid issues with accessing `Ember.VERSION`
+    if (!Ember) {
+      return;
+    }
+
+    if (!versionTest(Ember.VERSION, EMBER_VERSIONS_SUPPORTED)) {
+      // Wrong inspector version. Redirect to the correct version.
+      sendVersionMiss(Ember);
+      return;
+    }
+
+    // prevent from injecting twice
+    if (!window.EmberInspector) {
+      let emberDebugMainModule = (await import('../main')).default;
+      if (!emberDebugMainModule) {
+        return;
+      }
+      window.EmberInspector = emberDebugMainModule;
+      window.EmberInspector.Adapter = adapter;
+
+      onApplicationStart(function appStarted(instance) {
+        let app = instance.application;
+        if (!('__inspector__booted' in app)) {
+          // Watch for app reset/destroy
+          app.reopen({
+            reset: function () {
+              this.__inspector__booted = false;
+              this._super.apply(this, arguments);
+            },
+          });
+        }
+
+        if (instance && !('__inspector__booted' in instance)) {
+          instance.reopen({
+            // Clean up on instance destruction
+            willDestroy() {
+              if (window.EmberInspector.owner === instance) {
+                window.EmberInspector.destroyContainer();
+                window.EmberInspector.clear();
+              }
+              return this._super.apply(this, arguments);
+            },
+          });
+
+          if (!window.EmberInspector._application) {
+            setTimeout(() => bootEmberInspector(instance), 0);
+          }
+        }
+      });
+    }
+  };
+}

package/ember_debug/lib/version-test.js

@@ -0,0 +1,73 @@
+/* eslint-disable ember/no-test-import-export */
+
+/**
+ * @method compare
+ * @param {Number} val
+ * @param {Number} number
+ * @return {Number}
+ *  0: same
+ * -1: <
+ *  1: >
+ */
+function compare(val, number) {
+  if (val === number) {
+    return 0;
+  } else if (val < number) {
+    return -1;
+  } else if (val > number) {
+    return 1;
+  }
+}
+
+/**
+ * Remove -alpha, -beta, etc from versions
+ *
+ * @param {String} version
+ * @return {String} The cleaned up version
+ */
+function cleanupVersion(version) {
+  return version.replace(/-.*/g, '');
+}
+
+/**
+ * Compares two Ember versions.
+ *
+ * Returns:
+ * `-1` if version1 < version
+ * 0 if version1 == version2
+ * 1 if version1 > version2
+ *
+ * @param {String} version1
+ * @param {String} version2
+ * @return {Boolean} result of the comparison
+ */
+function compareVersion(version1, version2) {
+  let compared, i;
+  version1 = cleanupVersion(version1).split('.');
+  version2 = cleanupVersion(version2).split('.');
+  for (i = 0; i < 3; i++) {
+    compared = compare(+version1[i], +version2[i]);
+    if (compared !== 0) {
+      return compared;
+    }
+  }
+  return 0;
+}
+
+/**
+ * Checks if a version is between two different versions.
+ * version should be >= left side, < right side
+ *
+ * @param {String} version1
+ * @param {String} version2
+ * @return {Boolean}
+ */
+export default function versionTest(version, between) {
+  var fromVersion = between[0];
+  var toVersion = between[1];
+
+  if (compareVersion(version, fromVersion) === -1) {
+    return false;
+  }
+  return !toVersion || compareVersion(version, toVersion) === -1;
+}

package/ember_debug/lib/versions.js

@@ -0,0 +1,3 @@
+export const EMBER_VERSIONS_SUPPORTED = ['3.16.0', ''];
+
+export const PREVIOUS_EMBER_VERSIONS_SUPPORTED = ['0.0.0', '2.7.0', '3.4.0'];

package/ember_debug/package.json

@@ -1,5 +1,6 @@
 {
   "name": "ember-debug",
+  "version": "0.0.0",
   "private": true,
   "type": "module",
   "scripts": {
@@ -17,6 +18,7 @@
     "backburner.js": "^2.8.0",
     "glob": "^11.0.2",
     "rollup": "^4.39.0",
+    "rollup-plugin-delete": "^3.0.1",
     "source-map-js": "^1.2.1"
   },
   "exports": {

package/ember_debug/rollup.config.js

@@ -2,47 +2,23 @@ import { nodeResolve } from '@rollup/plugin-node-resolve';
 import commonjs from '@rollup/plugin-commonjs';
 import { babel } from '@rollup/plugin-babel';
 import { globSync } from 'glob';
+import del from 'rollup-plugin-delete';
 
 export default {
   input: [
     'main.js',
-    ...globSync('adapters/**/*.js'),
     'utils/version.js',
+    'utils/type-check.js',
     'port.js',
     'utils/ember.js',
     'models/profile-node.js',
     'libs/promise-assembler.js',
+    'lib/versions.js',
+    ...globSync('entrypoints/*.js'),
   ],
   output: {
-    format: 'amd',
-    amd: {
-      autoId: true,
-      // id: 'ember-debug/[name]',
-      basePath: 'ember-debug',
-    },
-    chunkFileNames: '[name].js',
     dir: 'dist',
   },
 
-  plugins: [
-    babel(),
-    nodeResolve(),
-    commonjs(),
-    /**
-     * this plugin forces each of the intenral dependencies for each of the chunks to be prefixed with ember-debug
-     */
-    {
-      name: 'rollup-plugin-name-amd-modules',
-      renderChunk(code) {
-        let splitCode = code.split('\n');
-
-        splitCode[0] = splitCode[0].replaceAll(
-          /'\.\/([^']*)'/g,
-          `'ember-debug/$1'`,
-        );
-
-        return splitCode.join('\n');
-      },
-    },
-  ],
+  plugins: [babel(), nodeResolve(), commonjs(), del({ targets: 'dist' })],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-inspector",
-  "version": "4.13.1-alpha.2025.7.29+4b5ac6d",
+  "version": "4.13.1-alpha.2025.7.30+5226815",
   "description": "Extends developer tools to allow you to better inspect your Ember.js apps.",
   "repository": "https://github.com/emberjs/ember-inspector",
   "license": "MIT",
@@ -124,14 +124,15 @@
     "tracked-toolbox": "^2.0.0",
     "typescript": "^5.7.2",
     "typescript-eslint": "^8.18.2",
-    "webpack": "^5.97.1"
+    "webpack": "^5.97.1",
+    "ember-debug": "0.0.0"
   },
   "engines": {
-    "node": ">= 18",
+    "node": ">= 22",
     "pnpm": "^9.0.0"
   },
   "volta": {
-    "node": "18.20.4",
+    "node": "22.17.1",
     "pnpm": "9.12.1"
   },
   "publishConfig": {
@@ -140,11 +141,6 @@
   "ember": {
     "edition": "octane"
   },
-  "ember-addon": {
-    "paths": [
-      "lib/ui"
-    ]
-  },
   "emberVersionsSupported": [
     "3.16.0",
     ""

package/skeletons/bookmarklet/load_inspector.js

@@ -72,6 +72,7 @@
 
   function injectEmberDebug(fileName) {
     var script = document.createElement('script');
+    script.type = 'module';
     script.src = url + '/' + fileName;
     document.body.appendChild(script);
   }

package/skeletons/web-extension/content-script.js

@@ -90,6 +90,7 @@
       if (!injected) {
         // cannot use eval here, as the context is limited to the content script-
         const elem = document.createElement('script');
+        elem.type = 'module';
         elem.src = message.value;
         document.head.appendChild(elem);
         injected = true;

package/skeletons/web-extension/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "name": "Ember Inspector (Nightly)",
   "description": "Tool for debugging Ember applications.",
-  "version": "2025.7.29",
+  "version": "2025.7.30",
   "icons": {
     "16": "{{PANE_ROOT}}/assets/images/icon16.png",
     "38": "{{PANE_ROOT}}/assets/images/icon38.png",
@@ -67,12 +67,12 @@
     {
       "resources": [
         "scripts/in-page-script.js",
-        "panes-*/ember_debug.js"
+        "panes-*/*.js"
       ],
       "matches": [
         "*://*/*"
       ]
     }
   ],
-  "version_name": "4.13.1 (nightly build 2025.7.29 / 4b5ac6d)"
+  "version_name": "4.13.1 (nightly build 2025.7.30 / 5226815)"
 }

package/tests/index.html

@@ -31,7 +31,7 @@
     {{content-for "head-footer"}}
     {{content-for "test-head-footer"}}
   </head>
-  <body class="theme--light">
+  <body class="theme-light">
 
     {{content-for "body"}}
     {{content-for "test-body"}}
@@ -47,7 +47,6 @@
     <script src="{{rootURL}}assets/vendor.js"></script>
     <script src="{{rootURL}}assets/test-support.js"></script>
     <script src="{{rootURL}}assets/ember-inspector.js"></script>
-    <script src="{{rootURL}}ember_debug.js"></script>
     <script src="{{rootURL}}assets/tests.js"></script>
 
     {{content-for "body-footer"}}

package/tests/integration/injection-test.js

@@ -317,8 +317,8 @@ module('Integration | Injection', function (hooks) {
 
   test('inject ember debug via content and background scripts', async function (assert) {
     await inject(this.owner, assert);
-    const { requireModule } = getLoader(window.define, window.requireModule);
-    const emberDebug = requireModule('ember-debug/main');
+    const emberDebug = globalThis.EmberInspector;
+
     assert.notStrictEqual(
       emberDebug,
       undefined,
@@ -338,7 +338,7 @@ module('Integration | Injection', function (hooks) {
     await inject(this.owner, assert);
     assert.timeout(100);
 
-    const emberDebug = requireModule('ember-debug/main');
+    const emberDebug = globalThis.EmberInspector;
     const viewInspection = emberDebug.viewDebug.viewInspection;
 
     const inspectNearestCalled = new Promise((resolve) => {

package/tests/test-helper.js

@@ -8,9 +8,6 @@ import TestAdapter from './test-adapter';
 import setupSinon from 'ember-sinon-qunit';
 import registerWaiter from 'ember-raf-scheduler/test-support/register-waiter';
 
-// ensure ember-debug is required
-import 'ember-debug/main';
-
 registerWaiter();
 
 /**

package/ember_debug/vendor/loader.js

@@ -1,54 +0,0 @@
-/* eslint-disable */
-let define = window.define && ((...args) => window.define(...args)),
-  exports = undefined,
-  module = undefined,
-  require = window.requireModule,
-  requireModule = window.requireModule;
-/* eslint-enable */
-if (typeof define !== 'function' || typeof requireModule !== 'function') {
-  (function () {
-    let registry = {},
-      seen = {};
-
-    define = function (name, deps, callback) {
-      if (arguments.length < 3) {
-        callback = deps;
-        deps = [];
-      }
-      registry[name] = { deps, callback };
-    };
-
-    requireModule = function (name) {
-      if (seen[name]) {
-        return seen[name];
-      }
-
-      let mod = registry[name];
-      if (!mod) {
-        throw new Error(`Module: '${name}' not found.`);
-      }
-
-      seen[name] = {};
-
-      let deps = mod.deps;
-      let callback = mod.callback;
-      let reified = [];
-      let exports;
-
-      for (let i = 0, l = deps.length; i < l; i++) {
-        if (deps[i] === 'exports') {
-          reified.push((exports = {}));
-        } else {
-          reified.push(requireModule(deps[i]));
-        }
-      }
-
-      let value = callback.apply(this, reified);
-      seen[name] = exports || value;
-      return seen[name];
-    };
-
-    define.registry = registry;
-    define.seen = seen;
-  })();
-}