ember-inspector 4.13.1 → 4.15.0

package/dist/bookmarklet/panes-3-16-0/start-inspector-BIYQArZn.js

@@ -0,0 +1,334 @@
+import { EMBER_VERSIONS_SUPPORTED } from './versions.js';
+import { Namespace, Application, guidFor, VERSION } from './ember.js';
+
+/* 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}
+ */
+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;
+}
+
+function sendApps(adapter, apps) {
+  const serializedApps = apps.map(app => {
+    return {
+      applicationName: app.applicationName,
+      applicationId: app.applicationId
+    };
+  });
+  adapter.sendMessage({
+    type: 'apps-loaded',
+    apps: serializedApps,
+    from: 'inspectedWindow'
+  });
+}
+
+/**
+ * Get all the Ember.Application instances from Ember.Namespace.NAMESPACES
+ * and add our own applicationId and applicationName to them
+ * @return {*}
+ */
+function getApplications() {
+  var namespaces = Namespace.NAMESPACES;
+  var apps = namespaces.filter(function (namespace) {
+    return namespace instanceof Application;
+  });
+  return apps.map(function (app) {
+    // Add applicationId and applicationName to the app
+    var applicationId = guidFor(app);
+    var applicationName = app.name || app.modulePrefix || `(unknown app - ${applicationId})`;
+    Object.assign(app, {
+      applicationId,
+      applicationName
+    });
+    return app;
+  });
+}
+
+function bootEmberInspector(appInstance) {
+  appInstance.application.__inspector__booted = true;
+  appInstance.__inspector__booted = true;
+
+  // Boot the inspector (or re-boot if already booted, for example in tests)
+  window.EmberInspector._application = appInstance.application;
+  window.EmberInspector.owner = appInstance;
+  window.EmberInspector.start(true);
+}
+
+function setupInstanceInitializer(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-' + guidFor(app),
+      initialize: function (instance) {
+        callback(instance);
+      }
+    });
+  }
+}
+
+let channel = new MessageChannel();
+let port = channel.port1;
+window.postMessage('debugger-client', '*', [channel.port2]);
+let registeredMiss = false;
+
+/**
+ * This function is called if the app's Ember version
+ * is not supported by this version of the inspector.
+ *
+ * It sends a message to the inspector app to redirect
+ * to an inspector version that supports this Ember version.
+ */
+function sendVersionMiss(VERSION) {
+  if (registeredMiss) {
+    return;
+  }
+  registeredMiss = true;
+  port.addEventListener('message', message => {
+    if (message.type === 'check-version') {
+      sendVersionMismatch();
+    }
+  });
+  sendVersionMismatch();
+  port.start();
+  function sendVersionMismatch() {
+    port.postMessage({
+      name: 'version-mismatch',
+      version: VERSION,
+      from: 'inspectedWindow'
+    });
+  }
+}
+
+/* eslint-disable ember/no-test-import-export */
+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();
+  }
+}
+function onEmberReady(callback) {
+  var triggered = false;
+  var triggerOnce = function () {
+    if (triggered) {
+      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);
+}
+function startInspector(adapter) {
+  // There's probably a better way
+  // to determine when the application starts
+  // but this definitely works
+  function onApplicationStart(callback) {
+    const adapterInstance = new adapter();
+    adapterInstance.onMessageReceived(function (message) {
+      if (message.type === 'app-picker-loaded') {
+        sendApps(adapterInstance, getApplications());
+      }
+      if (message.type === 'app-selected') {
+        let current = window.EmberInspector._application;
+        let selected = getApplications().find(app => guidFor(app) === message.applicationId);
+        if (selected && current !== selected && selected.__deprecatedInstance__) {
+          bootEmberInspector(selected.__deprecatedInstance__);
+        }
+      }
+    });
+    var apps = getApplications();
+    sendApps(adapterInstance, apps);
+    function loadInstance(app) {
+      const applicationInstances = app._applicationInstances && [...app._applicationInstances];
+      let instance = app.__deprecatedInstance__ || applicationInstances[0];
+      if (instance) {
+        // App started
+        setupInstanceInitializer(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);
+        }
+      });
+    }
+    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 we don't have a way to know the Ember version at this point
+     * because the Ember app has not loaded and provided it somehow,
+     * we can't continue (we need the version to know what version of
+     * the Inspector to load).
+     */
+    if (!VERSION) {
+      return;
+    }
+
+    /**
+     * This is used to redirect to an old snapshot of the Inspector if the
+     * inspected app uses an older Ember version than supported versions.
+     * The code fits the Inspector supporting Ember back to 3.16: any version
+     * before 3.16 is necessarily a classic Ember app with Ember defined.
+     */
+    if (!versionTest(VERSION, EMBER_VERSIONS_SUPPORTED)) {
+      // Wrong inspector version. Redirect to the correct version.
+      sendVersionMiss(VERSION);
+      return;
+    }
+
+    // prevent from injecting twice
+    if (!window.EmberInspector) {
+      let emberDebugMainModule = (await import('./main.js')).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);
+          }
+        }
+      });
+    }
+  };
+}
+
+export { onEmberReady, startInspector };

package/dist/bookmarklet/panes-3-16-0/type-check.js

@@ -0,0 +1,119 @@
+import { EmberObject, inspect as inspect$1, Debug, meta, ComputedProperty, InternalsMetal } from './ember.js';
+
+/**
+ * Check if given key on the passed object is a computed property
+ * @param object
+ * @param key
+ * @return {boolean|*}
+ */
+function isComputed(object, key) {
+  // Ember > 3.10
+  if (Debug.isComputed && Debug.isComputed(object, key)) {
+    return true;
+  }
+  if (meta(object) && meta(object).peekDescriptors(key)) {
+    return !!meta(object).peekDescriptors(key)._getter;
+  }
+  if (getDescriptorFor(object, key) instanceof ComputedProperty) {
+    return true;
+  }
+}
+
+/**
+ * This allows us to pass in a COMPUTED_DECORATOR function and get the descriptor for it.
+ * It should be implemented Ember side eventually.
+ * @param {EmberObject} object The object we are inspecting
+ * @param {String} key The key for the property on the object
+ */
+function getDescriptorFor(object, key) {
+  if (object[key]?.isDescriptor) {
+    return object[key];
+  }
+
+  // exists longer than ember 3.10
+  if (Debug.isComputed) {
+    const {
+      descriptorForDecorator,
+      descriptorForProperty
+    } = InternalsMetal || {};
+    return descriptorForDecorator?.(object[key]) || descriptorForProperty?.(object, key);
+  }
+  return object[key];
+}
+function typeOf(obj) {
+  return Object.prototype.toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase();
+}
+function inspect(value) {
+  if (typeof value === 'function') {
+    return `${value.name || 'function'}() { ... }`;
+  } else if (value instanceof EmberObject) {
+    return value.toString();
+  } else if (value instanceof HTMLElement) {
+    return `<${value.tagName.toLowerCase()}>`;
+  } else if (typeOf(value) === 'array') {
+    if (value.length === 0) {
+      return '[]';
+    } else if (value.length === 1) {
+      return `[ ${inspect(value[0])} ]`;
+    } else {
+      return `[ ${inspect(value[0])}, ... ]`;
+    }
+  } else if (value instanceof Error) {
+    return `Error: ${value.message}`;
+  } else if (value === null) {
+    return 'null';
+  } else if (typeOf(value) === 'date') {
+    return value.toString();
+  } else if (typeof value === 'object') {
+    // `Ember.inspect` is able to handle this use case,
+    // but it is very slow as it loops over all props,
+    // so summarize to just first 2 props
+    // if it defines a toString, we use that instead
+    if (typeof value.toString === 'function' && value.toString !== Object.prototype.toString && value.toString !== Function.prototype.toString) {
+      try {
+        return `<Object:${value.toString()}>`;
+      } catch {
+        //
+      }
+    }
+    let ret = [];
+    let v;
+    let count = 0;
+    let broken = false;
+    for (let key in value) {
+      if (!('hasOwnProperty' in value) || value.hasOwnProperty(key)) {
+        if (count++ > 1) {
+          broken = true;
+          break;
+        }
+        v = value[key];
+        if (v === 'toString') {
+          continue;
+        } // ignore useless items
+        if (typeOf(v).includes('function')) {
+          v = `function ${v.name}() { ... }`;
+        }
+        if (typeOf(v) === 'array') {
+          v = `[Array : ${v.length}]`;
+        }
+        if (typeOf(v) === 'object') {
+          v = '[Object]';
+        }
+        // to avoid TypeError: Cannot convert a Symbol value to a string
+        if (typeOf(v) === 'symbol') {
+          v = v.toString();
+        }
+        ret.push(`${key}: ${v}`);
+      }
+    }
+    let suffix = ' }';
+    if (broken) {
+      suffix = ' ...}';
+    }
+    return `{ ${ret.join(', ')}${suffix}`;
+  } else {
+    return inspect$1(value);
+  }
+}
+
+export { getDescriptorFor, inspect, isComputed, typeOf };

package/dist/bookmarklet/panes-3-16-0/version.js

@@ -0,0 +1,90 @@
+/**
+ * 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;
+}
+
+/**
+ *
+ * @param specifier e.g. ^5.12.0
+ * @param version 5.13
+ * @return {boolean}
+ */
+function isInVersionSpecifier(specifier, version) {
+  let compared, i, version2;
+  let operator = specifier[0];
+  if (Number.isNaN(+operator)) {
+    specifier = specifier.slice(1);
+  }
+  specifier = cleanupVersion(specifier).split('.');
+  version2 = cleanupVersion(version).split('.');
+  if (operator === '~' && specifier[1] !== version2[1]) {
+    return false;
+  }
+  if (operator === '^' && specifier[0] !== version2[0]) {
+    return false;
+  }
+  if (operator === '>' && specifier[0] > version2[0]) {
+    return false;
+  }
+  for (i = 0; i < 3; i++) {
+    compared = compare(+specifier[i], +version2[i]);
+    if (compared < 0) {
+      return true;
+    }
+    if (compared > 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Remove -alpha, -beta, etc from versions
+ *
+ * @param {String} version
+ * @return {String} The cleaned up version
+ */
+function cleanupVersion(version) {
+  return version.replace(/-.*/g, '');
+}
+
+/**
+ * @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;
+  }
+}
+
+export { compareVersion, isInVersionSpecifier };

package/dist/bookmarklet/panes-3-16-0/versions.js

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

package/dist/bookmarklet/panes-3-16-0/web-extension-OWnXJ_XK.js

@@ -0,0 +1,144 @@
+import { B as BasicAdapter } from './basic-B1dkgN3d.js';
+import { typeOf } from './type-check.js';
+import { getEnv } from './ember.js';
+import { r as run } from './runloop-6_0lpzTA.js';
+
+const {
+  isArray
+} = Array;
+const {
+  keys
+} = Object;
+class WebExtension extends BasicAdapter {
+  // eslint-disable-next-line ember/classic-decorator-hooks
+  init() {
+    this._channel = new MessageChannel();
+    this._chromePort = this._channel?.port1;
+    super.init();
+  }
+  connect() {
+    const channel = this._channel;
+    return super.connect().then(() => {
+      window.postMessage('debugger-client', '*', [channel.port2]);
+      this._listen();
+    }, null);
+  }
+  sendMessage(options = {}) {
+    // If prototype extensions are disabled, `Ember.A()` arrays
+    // would not be considered native arrays, so it's not possible to
+    // "clone" them through postMessage unless they are converted to a
+    // native array.
+    options = deepClone(options);
+    try {
+      this._chromePort.postMessage(options);
+    } catch (e) {
+      console.log('failed to send message', e);
+    }
+  }
+
+  /**
+   * Open the devtools "Elements" and select an DOM node.
+   *
+   * @param  {Node|Function} value The DOM node to select
+   */
+  inspectValue(value) {
+    // NOTE:
+    //
+    // Basically, we are just trying to call `inspect(node)` here.
+    // However, `inspect` is a special function that is in the global
+    // scope but not on the global object (i.e. `window.inspect`) does
+    // not work. This sometimes causes problems, because, e.g. if the
+    // page has a div with the ID `inspect`, `window.inspect` will point
+    // to that div and shadow the "global" inspect function with no way
+    // to get it back. That causes "`inspect` is not a function" errors.
+    //
+    // As it turns out, however, when the extension page evals, the
+    // `inspect` function does not get shadowed. So, we can ask the
+    // inspector extension page to call that function for us, using
+    // `inspected.Window.eval('inspect(node)')`.
+    //
+    // However, since we cannot just send the DOM node directly to the
+    // extension, we will have to store it in a temporary global variable
+    // so that the extension can find it.
+
+    let name = `__EMBER_INSPECTOR_${(Math.random() * 100000000).toFixed(0)}`;
+    window[name] = value;
+    this.namespace.port.send('view:inspectJSValue', {
+      name
+    });
+  }
+  _listen() {
+    let chromePort = this._chromePort;
+    chromePort.addEventListener('message', event => {
+      const message = event.data;
+
+      // We should generally not be run-wrapping here. Starting a runloop in
+      // ember-debug will cause the inspected app to revalidate/rerender. We
+      // are generally not intending to cause changes to the rendered output
+      // of the app, so this is generally unnecessary, and in big apps this
+      // could be quite slow. There is nothing special about the `view:*`
+      // messages – I (GC) just happened to have reviewed all of them recently
+      // and can be quite sure that they don't need the runloop. We should
+      // audit the rest of them and see if we can remove the else branch. I
+      // think we most likely can. In the limited cases (if any) where the
+      // runloop is needed, the callback code should just do the wrapping
+      // themselves.
+      if (message.type.startsWith('view:')) {
+        this._messageReceived(message);
+      } else {
+        run(() => {
+          this._messageReceived(message);
+        });
+      }
+    });
+    chromePort.start();
+  }
+}
+
+// On some older Ember version `Ember.ENV.EXTEND_PROTOTYPES` is not
+// guarenteed to be an object. While this code only support 3.4+ (all
+// of which normalizes `EXTEND_PROTOTYPES` for us), startup-wrapper.js
+// eagerly require/load ember-debug modules, which ultimately causes
+// this top-level code to run, even we are going to pick a different
+// adapter later. See GH #1114.
+const HAS_ARRAY_PROTOTYPE_EXTENSIONS = (() => {
+  try {
+    return getEnv().EXTEND_PROTOTYPES.Array === true;
+  } catch {
+    return false;
+  }
+})();
+let deepClone;
+if (HAS_ARRAY_PROTOTYPE_EXTENSIONS) {
+  deepClone = function deepClone(item) {
+    return item;
+  };
+} else {
+  /**
+   * Recursively clones all arrays. Needed because Chrome
+   * refuses to clone Ember Arrays when extend prototypes is disabled.
+   *
+   * If the item passed is an array, a clone of the array is returned.
+   * If the item is an object or an array, or array properties/items are cloned.
+   *
+   * @param {Mixed} item The item to clone
+   * @return {Mixed}
+   */
+  deepClone = function deepClone(item) {
+    let clone = item;
+    if (isArray(item)) {
+      clone = new Array(item.length);
+      item.forEach((child, key) => {
+        clone[key] = deepClone(child);
+      });
+    } else if (item && typeOf(item) === 'object') {
+      clone = {};
+      keys(item).forEach(key => {
+        clone[key] = deepClone(item[key]);
+      });
+    }
+    return clone;
+  };
+}
+
+export { WebExtension as W };