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

package/ember_debug/lib/setup-instance-initializer.js

@@ -0,0 +1,16 @@
+/* eslint-disable ember/new-module-imports */
+export default function setupInstanceInitializer(Ember, app, callback) {
+  if (!app.__inspector__setup) {
+    app.__inspector__setup = true;
+
+    // We include the app's guid in the initializer name because in Ember versions < 3
+    // registering an instance initializer with the same name, even if on a different app,
+    // triggers an error because instance initializers seem to be global instead of per app.
+    app.instanceInitializer({
+      name: 'ember-inspector-app-instance-booted-' + Ember.guidFor(app),
+      initialize: function (instance) {
+        callback(instance);
+      },
+    });
+  }
+}

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/libs/capture-render-tree.js

@@ -1,4 +1,4 @@
-import { captureRenderTree, getEnv } from 'ember-debug/utils/ember';
+import { captureRenderTree, getEnv } from '../utils/ember';
 
 let capture = captureRenderTree;
 // Ember 3.14+ comes with debug render tree, but the version in 3.14.0/3.14.1 is buggy

package/ember_debug/libs/promise-assembler.js

@@ -5,10 +5,10 @@
  and Yapp Labs (@yapplabs).
  */
 
-import Promise from 'ember-debug/models/promise';
-import RSVP from 'ember-debug/utils/rsvp';
-import BaseObject from 'ember-debug/utils/base-object';
-import Evented from 'ember-debug/utils/evented';
+import Promise from '../models/promise';
+import { RSVP } from '../utils/ember';
+import BaseObject from '../utils/base-object';
+import Evented from '../utils/evented';
 
 class PromiseAssembler extends BaseObject {
   // RSVP lib to debug

package/ember_debug/libs/render-tree.js

@@ -1,7 +1,7 @@
-import captureRenderTree from './capture-render-tree';
-import { guidFor } from 'ember-debug/utils/ember/object/internals';
-import { inspect } from 'ember-debug/utils/type-check';
-import { isInVersionSpecifier } from 'ember-debug/utils/version';
+import captureRenderTree from './capture-render-tree.js';
+import { guidFor } from '../utils/ember/object/internals';
+import { inspect } from '../utils/type-check';
+import { isInVersionSpecifier } from '../utils/version';
 import {
   VERSION,
   EmberDestroyable,
@@ -9,7 +9,7 @@ import {
   GlimmerReference,
   GlimmerRuntime,
   GlimmerUtil,
-} from 'ember-debug/utils/ember';
+} from '../utils/ember';
 
 class InElementSupportProvider {
   constructor(owner) {

package/ember_debug/libs/source-map.js

@@ -1,4 +1,4 @@
-import BaseObject from 'ember-debug/utils/base-object';
+import BaseObject from '../utils/base-object';
 import * as SourceMap from 'source-map-js';
 const notFoundError = new Error('Source map url not found');
 

package/ember_debug/libs/view-inspection.js

@@ -1,6 +1,6 @@
-import classify from 'ember-debug/utils/classify';
-import bound from 'ember-debug/utils/bound-method';
-import getObjectName from '../utils/get-object-name';
+import classify from '../utils/classify';
+import bound from '../utils/bound-method';
+import getObjectName from '../utils/get-object-name.js';
 
 function makeHighlight(id) {
   return `<div id="ember-inspector-highlight-${id}" role="presentation"></div>`;

package/ember_debug/main.js

@@ -1,23 +1,20 @@
-import BasicAdapter from 'ember-debug/adapters/basic';
-import Port from 'ember-debug/port';
-import ObjectInspector from 'ember-debug/object-inspector';
-import GeneralDebug from 'ember-debug/general-debug';
-import RenderDebug from 'ember-debug/render-debug';
-import ViewDebug from 'ember-debug/view-debug';
-import RouteDebug from 'ember-debug/route-debug';
-import DataDebug from 'ember-debug/data-debug';
-import PromiseDebug from 'ember-debug/promise-debug';
-import ContainerDebug from 'ember-debug/container-debug';
-import DeprecationDebug from 'ember-debug/deprecation-debug';
-import Session from 'ember-debug/services/session';
-
-import { Application, Namespace } from 'ember-debug/utils/ember';
-import {
-  guidFor,
-  setGuidPrefix,
-} from 'ember-debug/utils/ember/object/internals';
-import { run } from 'ember-debug/utils/ember/runloop';
-import BaseObject from 'ember-debug/utils/base-object';
+import BasicAdapter from './adapters/basic';
+import Port from './port';
+import ObjectInspector from './object-inspector';
+import GeneralDebug from './general-debug';
+import RenderDebug from './render-debug';
+import ViewDebug from './view-debug';
+import RouteDebug from './route-debug';
+import DataDebug from './data-debug';
+import PromiseDebug from './promise-debug';
+import ContainerDebug from './container-debug';
+import DeprecationDebug from './deprecation-debug';
+import Session from './services/session';
+
+import { Application, Namespace } from './utils/ember';
+import { guidFor, setGuidPrefix } from './utils/ember/object/internals';
+import { run } from './utils/ember/runloop';
+import BaseObject from './utils/base-object';
 
 class EmberDebug extends BaseObject {
   /**

package/ember_debug/models/profile-manager.js

@@ -1,8 +1,8 @@
-import ProfileNode from './profile-node';
-import Ember from 'ember-debug/utils/ember';
-import { compareVersion } from 'ember-debug/utils/version';
+import ProfileNode from './profile-node.js';
+import { VERSION } from '../utils/ember';
+import { compareVersion } from '../utils/version';
 
-import { later, scheduleOnce, cancel } from 'ember-debug/utils/ember/runloop';
+import { later, scheduleOnce, cancel } from '../utils/ember/runloop';
 
 function getEdges(first, last, closest) {
   let start = null;
@@ -75,8 +75,7 @@ export default class ProfileManager {
     this.stylesheet = insertStylesheet();
     // keep track of all the active highlights
     this.highlights = [];
-    // eslint-disable-next-line ember/new-module-imports
-    this.isHighlightEnabled = compareVersion(Ember?.VERSION, '3.20.0') !== -1;
+    this.isHighlightEnabled = compareVersion(VERSION, '3.20.0') !== -1;
   }
 
   began(timestamp, payload, now) {

package/ember_debug/models/profile-node.js

@@ -3,7 +3,7 @@
 
   @class ProfileNode
 **/
-import { guidFor } from 'ember-debug/utils/ember/object/internals';
+import { guidFor } from '../utils/ember/object/internals';
 
 function get(obj, key) {
   return obj.get ? obj.get(key) : obj[key];

package/ember_debug/models/promise.js

@@ -1,5 +1,5 @@
-import { typeOf } from 'ember-debug/utils/type-check';
-import BaseObject from 'ember-debug/utils/base-object';
+import { typeOf } from '../utils/type-check';
+import BaseObject from '../utils/base-object';
 
 const dateComputed = function () {
   return function (target, propertyKey) {

package/ember_debug/object-inspector.js

@@ -1,13 +1,13 @@
 /* eslint-disable ember/no-private-routing-service */
-import DebugPort from './debug-port';
-import bound from 'ember-debug/utils/bound-method';
+import DebugPort from './debug-port.js';
+import bound from './utils/bound-method';
 import {
   isComputed,
   getDescriptorFor,
   typeOf,
   inspect,
-} from 'ember-debug/utils/type-check';
-import { compareVersion } from 'ember-debug/utils/version';
+} from './utils/type-check';
+import { compareVersion } from './utils/version';
 import {
   EmberObject,
   meta as emberMeta,
@@ -21,11 +21,11 @@ import {
   GlimmerComponent,
   GlimmerReference,
   GlimmerValidator,
-} from 'ember-debug/utils/ember';
-import { cacheFor, guidFor } from 'ember-debug/utils/ember/object/internals';
-import { _backburner, join } from 'ember-debug/utils/ember/runloop';
-import emberNames from './utils/ember-object-names';
-import getObjectName from './utils/get-object-name';
+} from './utils/ember';
+import { cacheFor, guidFor } from './utils/ember/object/internals';
+import { _backburner, join } from './utils/ember/runloop';
+import emberNames from './utils/ember-object-names.js';
+import getObjectName from './utils/get-object-name.js';
 
 let tagValue, tagValidate, track, tagForProperty;
 

package/ember_debug/package.json

@@ -1,5 +1,6 @@
 {
   "name": "ember-debug",
+  "version": "0.0.0",
   "private": true,
   "type": "module",
   "scripts": {
@@ -17,9 +18,10 @@
     "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": {
-    "./*": "./*.js"
+    "./*": "./dist/*.js"
   }
 }

package/ember_debug/port.js

@@ -1,7 +1,7 @@
-import { guidFor } from 'ember-debug/utils/ember/object/internals';
-import { run } from 'ember-debug/utils/ember/runloop';
-import BaseObject from 'ember-debug/utils/base-object';
-import Evented from 'ember-debug/utils/evented';
+import { guidFor } from './utils/ember/object/internals';
+import { run } from './utils/ember/runloop';
+import BaseObject from './utils/base-object';
+import Evented from './utils/evented';
 
 export default class extends BaseObject {
   constructor(data) {

package/ember_debug/promise-debug.js

@@ -1,7 +1,7 @@
-import DebugPort from './debug-port';
-import PromiseAssembler from 'ember-debug/libs/promise-assembler';
-import { debounce } from 'ember-debug/utils/ember/runloop';
-import RSVP from 'ember-debug/utils/rsvp';
+import DebugPort from './debug-port.js';
+import PromiseAssembler from './libs/promise-assembler';
+import { debounce } from './utils/ember/runloop';
+import { RSVP } from './utils/ember';
 
 export default class extends DebugPort {
   get objectInspector() {

package/ember_debug/render-debug.js

@@ -1,9 +1,9 @@
-import DebugPort from './debug-port';
-import ProfileManager from './models/profile-manager';
+import DebugPort from './debug-port.js';
+import ProfileManager from './models/profile-manager.js';
 
-import { subscribe } from 'ember-debug/utils/ember/instrumentation';
-import { _backburner } from 'ember-debug/utils/ember/runloop';
-import bound from 'ember-debug/utils/bound-method';
+import { subscribe } from './utils/ember';
+import { _backburner } from './utils/ember/runloop';
+import bound from './utils/bound-method';
 
 // Initial setup, that has to occur before the EmberObject init for some reason
 let profileManager = new ProfileManager();

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/ember_debug/route-debug.js

@@ -1,11 +1,11 @@
 /* eslint-disable ember/no-private-routing-service */
-import DebugPort from './debug-port';
-import { compareVersion } from 'ember-debug/utils/version';
-import { VERSION } from 'ember-debug/utils/ember';
-import classify from 'ember-debug/utils/classify';
-import dasherize from 'ember-debug/utils/dasherize';
-import { _backburner, later } from 'ember-debug/utils/ember/runloop';
-import bound from 'ember-debug/utils/bound-method';
+import DebugPort from './debug-port.js';
+import { compareVersion } from './utils/version';
+import { VERSION } from './utils/ember';
+import classify from './utils/classify';
+import dasherize from './utils/dasherize';
+import { _backburner, later } from './utils/ember/runloop';
+import bound from './utils/bound-method';
 
 const { hasOwnProperty } = Object.prototype;
 

package/ember_debug/services/session.js

@@ -1,4 +1,4 @@
-import BaseObject from 'ember-debug/utils/base-object';
+import BaseObject from '../utils/base-object';
 
 class Session extends BaseObject {
   setItem(/*key, val*/) {}

package/ember_debug/utils/ember/object/internals.js

@@ -1,9 +1,4 @@
-import Ember, { ObjectInternals } from '../../ember';
-
-// eslint-disable-next-line ember/new-module-imports
-let cacheFor = ObjectInternals?.cacheFor ?? Ember.cacheFor;
-// eslint-disable-next-line ember/new-module-imports
-let emberGuidFor = ObjectInternals?.guidFor ?? Ember.guidFor;
+import { cacheFor, guidFor as emberGuidFor } from '../../ember.js';
 
 // it can happen that different ember apps/iframes have the same id for different objects
 // since the implementation is just a counter, so we add a prefix per iframe & app

package/ember_debug/utils/ember/runloop.js

@@ -1,5 +1,5 @@
-import Ember, { Runloop as EmberRunloop } from '../ember';
-import * as runloop from './own-runloop';
+import { Runloop as EmberRunloop } from '../ember.js';
+import * as runloop from './own-runloop.js';
 
 // it could happen that runloop is available but _backburner is not exported (dead code)
 // then we need to use our own.
@@ -11,11 +11,6 @@ const keys = ['cancel', 'debounce', 'join', 'later', 'scheduleOnce'];
 if (EmberRunloop) {
   module = EmberRunloop;
   _backburner = EmberRunloop._backburner || EmberRunloop.backburner;
-} else {
-  // eslint-disable-next-line ember/new-module-imports
-  module = Ember?.run || module;
-  // eslint-disable-next-line ember/new-module-imports
-  _backburner = Ember?.run?.backburner || _backburner;
 }
 
 if (!keys.every((k) => k in module)) {