ember-inspector 4.13.1 → 4.15.0

package/dist/bookmarklet/panes-3-16-0/base-object-HAEdWjmg.js

@@ -0,0 +1,59 @@
+function _applyDecoratedDescriptor(i, e, r, n, l) {
+  var a = {};
+  return Object.keys(n).forEach(function (i) {
+    a[i] = n[i];
+  }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, ("value" in a || a.initializer) && (a.writable = true), a = r.slice().reverse().reduce(function (r, n) {
+    return n(i, e, r) || r;
+  }, a), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a;
+}
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+function _initializerDefineProperty(e, i, r, l) {
+  r && Object.defineProperty(e, i, {
+    enumerable: r.enumerable,
+    configurable: r.configurable,
+    writable: r.writable,
+    value: r.initializer ? r.initializer.call(l) : void 0
+  });
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+class BaseObject {
+  constructor(data) {
+    _defineProperty(this, "isDestroyed", false);
+    Object.assign(this, data || {});
+    this.init();
+  }
+  init() {}
+  willDestroy() {
+    this.isDestroying = true;
+  }
+  destroy() {
+    this.willDestroy();
+    this.isDestroyed = true;
+  }
+  reopen(data) {
+    Object.assign(this, data);
+  }
+}
+
+export { BaseObject as B, _defineProperty as _, _applyDecoratedDescriptor as a, _initializerDefineProperty as b };

package/dist/bookmarklet/panes-3-16-0/basic-B1dkgN3d.js

@@ -0,0 +1,149 @@
+import { B as BaseObject, _ as _defineProperty } from './base-object-HAEdWjmg.js';
+
+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();
+  }
+}
+
+class BasicAdapter extends BaseObject {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "_isReady", false);
+    _defineProperty(this, "_pendingMessages", []);
+  }
+  // eslint-disable-next-line ember/classic-decorator-hooks
+  init() {
+    Promise.resolve(this.connect()).then(() => {
+      this.onConnectionReady();
+    }, null);
+    this._messageCallbacks = [];
+  }
+  debug() {
+    return console.debug(...arguments);
+  }
+  log() {
+    return console.log(...arguments);
+  }
+
+  /**
+   * A wrapper for `console.warn`.
+   *
+   * @method warn
+   */
+  warn() {
+    return console.warn(...arguments);
+  }
+
+  /**
+    Used to send messages to EmberExtension
+     @param {Object} type the message to the send
+  */
+  sendMessage(/* options */) {}
+
+  /**
+    Register functions to be called
+    when a message from EmberExtension is received
+     @param {Function} callback
+  */
+  onMessageReceived(callback) {
+    this._messageCallbacks.push(callback);
+  }
+
+  /**
+    Inspect a js value or specific DOM node. This usually
+    means using the current environment's tools
+    to inspect the node in the DOM.
+     For example, in chrome, `inspect(node)`
+    will open the Elements tab in dev tools
+    and highlight the DOM node.
+    For functions, it will open the sources tab and goto the definition
+    @param {Node|Function} node
+  */
+  inspectValue(/* value */) {}
+  _messageReceived(message) {
+    this._messageCallbacks.forEach(callback => {
+      callback(message);
+    });
+  }
+
+  /**
+   * Handle an error caused by EmberDebug.
+   *
+   * This function rethrows in development and test envs,
+   * but warns instead in production.
+   *
+   * The idea is to control errors triggered by the inspector
+   * and make sure that users don't get mislead by inspector-caused
+   * bugs.
+   *
+   * @method handleError
+   * @param {Error} error
+   */
+  handleError(error) {
+    if (error && error instanceof Error) {
+      error = `Error message: ${error.message}\nStack trace: ${error.stack}`;
+    }
+    this.warn(`Ember Inspector has errored.\n` + `This is likely a bug in the inspector itself.\n` + `You can report bugs at https://github.com/emberjs/ember-inspector.\n${error}`);
+  }
+
+  /**
+     A promise that resolves when the connection
+    with the inspector is set up and ready.
+     @return {Promise}
+  */
+  connect() {
+    return new Promise((resolve, reject) => {
+      onReady(() => {
+        if (this.isDestroyed) {
+          reject();
+        }
+        this.interval = setInterval(() => {
+          if (document.documentElement.dataset.emberExtension) {
+            clearInterval(this.interval);
+            resolve();
+          }
+        }, 10);
+      });
+    });
+  }
+  willDestroy() {
+    super.willDestroy();
+    clearInterval(this.interval);
+  }
+  send(options) {
+    if (this._isReady) {
+      this.sendMessage(...arguments);
+    } else {
+      this._pendingMessages.push(options);
+    }
+  }
+
+  /**
+    Called when the connection is set up.
+    Flushes the pending messages.
+  */
+  onConnectionReady() {
+    // Flush pending messages
+    const messages = this._pendingMessages;
+    messages.forEach(options => this.sendMessage(options));
+    messages.length = 0;
+    this._isReady = true;
+  }
+}
+
+var basic = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: BasicAdapter
+});
+
+export { BasicAdapter as B, basic as b, onReady as o };

package/dist/bookmarklet/panes-3-16-0/basic-debug.js

@@ -0,0 +1,10 @@
+import { l as loadEmberDebugInWebpage } from './load-ember-debug-in-webpage-DCWcJhQm.js';
+
+loadEmberDebugInWebpage(async () => {
+  const {
+    onEmberReady,
+    startInspector
+  } = await import('./start-inspector-BIYQArZn.js');
+  const adapter = (await import('./basic-B1dkgN3d.js').then(function (n) { return n.b; })).default;
+  onEmberReady(startInspector(adapter));
+});

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

@@ -0,0 +1,32 @@
+import { B as BasicAdapter } from './basic-B1dkgN3d.js';
+import './base-object-HAEdWjmg.js';
+
+class bookmarklet extends BasicAdapter {
+  // eslint-disable-next-line ember/classic-decorator-hooks
+  init() {
+    super.init();
+    this._listen();
+  }
+  sendMessage(options) {
+    options = options || {};
+    window.emberInspector.w.postMessage(options, window.emberInspector.url);
+  }
+  _listen() {
+    window.addEventListener('message', e => {
+      if (e.origin !== window.emberInspector.url) {
+        return;
+      }
+      const message = e.data;
+      if (message.from === 'devtools') {
+        this._messageReceived(message);
+      }
+    });
+    window.onunload = () => {
+      this.sendMessage({
+        unloading: true
+      });
+    };
+  }
+}
+
+export { bookmarklet as default };

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

@@ -0,0 +1,10 @@
+import { l as loadEmberDebugInWebpage } from './load-ember-debug-in-webpage-DCWcJhQm.js';
+
+loadEmberDebugInWebpage(async () => {
+  const {
+    onEmberReady,
+    startInspector
+  } = await import('./start-inspector-BIYQArZn.js');
+  const adapter = (await import('./bookmarklet-BZWtwuX-.js')).default;
+  onEmberReady(startInspector(adapter));
+});

package/dist/bookmarklet/panes-3-16-0/chrome-P6FSEUf1.js

@@ -0,0 +1,10 @@
+import { W as WebExtension } from './web-extension-OWnXJ_XK.js';
+import './basic-B1dkgN3d.js';
+import './base-object-HAEdWjmg.js';
+import './type-check.js';
+import './ember.js';
+import './runloop-6_0lpzTA.js';
+
+class chrome extends WebExtension {}
+
+export { chrome as default };

package/dist/bookmarklet/panes-3-16-0/chrome-debug.js

@@ -0,0 +1,10 @@
+import { l as loadEmberDebugInWebpage } from './load-ember-debug-in-webpage-DCWcJhQm.js';
+
+loadEmberDebugInWebpage(async () => {
+  const {
+    onEmberReady,
+    startInspector
+  } = await import('./start-inspector-BIYQArZn.js');
+  const adapter = (await import('./chrome-P6FSEUf1.js')).default;
+  onEmberReady(startInspector(adapter));
+});

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

@@ -0,0 +1,166 @@
+/* eslint-disable ember/new-module-imports */
+let Ember;
+try {
+  Ember = requireModule('ember/barrel').default;
+} catch {
+  // pass through
+}
+try {
+  Ember = Ember || requireModule('ember').default;
+} catch {
+  Ember = window.Ember;
+}
+const wrappedRequire = function (id) {
+  try {
+    return Ember.__loader.require(id);
+  } catch {
+    return requireModule(id);
+  }
+};
+function emberSafeRequire(id) {
+  try {
+    return wrappedRequire(id);
+  } catch {
+    return undefined;
+  }
+}
+let Application, ApplicationModule, Namespace, ActionHandler, ControllerMixin, CoreObject, Debug, MutableEnumerable, NativeArray, ArrayProxy, MutableArray, Component, Observable, Evented, PromiseProxyMixin, Service, ObjectProxy, InternalsMetal, InternalsRuntime, InternalsUtils, InternalsViews, EmberDestroyable, ObjectInternals, Instrumentation, Runloop, GlimmerComponent, GlimmerManager, GlimmerReference, GlimmerRuntime, GlimmerUtil, GlimmerValidator, RSVP, VERSION, ComputedProperty, meta, get, set, computed, EmberObject, Owner, captureRenderTree, getEnv, getOwner;
+
+// This global is defined in Embroider to bring Vite support to the Inspector.
+// Having it defined is enough to assert the inspected app runs with Vite.
+if (globalThis.emberInspectorApps) {
+  // emberInspectorApps has been implemented as an array to support multiple
+  // apps in the future. So far, the inspector has supported only one app, so
+  // we rely on the first item in the array to keep the current behavior.
+  const appLoader = globalThis.emberInspectorApps[0];
+  const internalEmberModules = await appLoader.loadCompatInspector();
+  Application = internalEmberModules.Application.default;
+  ApplicationModule = internalEmberModules.Application;
+  Namespace = internalEmberModules.ApplicationNamespace.default;
+  NativeArray = internalEmberModules.Array.NativeArray;
+  MutableArray = internalEmberModules.ArrayMutable.default;
+  ArrayProxy = internalEmberModules.ArrayProxy.default;
+  Component = internalEmberModules.Component.default;
+  ControllerMixin = internalEmberModules.Controller.ControllerMixin;
+  Debug = internalEmberModules.Debug;
+  CoreObject = internalEmberModules.ObjectCore.default;
+  MutableEnumerable = internalEmberModules.EnumerableMutable.default;
+  getEnv = internalEmberModules.InternalsEnvironment?.getENV;
+  meta = internalEmberModules.InternalsMeta?.meta;
+  InternalsMetal = internalEmberModules.InternalsMetal;
+  ComputedProperty = InternalsMetal?.ComputedProperty;
+  InternalsRuntime = internalEmberModules.InternalsRuntime;
+  InternalsUtils = internalEmberModules.InternalsUtils;
+  InternalsViews = internalEmberModules.InternalsViews;
+  ObjectInternals = internalEmberModules.ObjectInternals;
+  Instrumentation = internalEmberModules.Instrumentation;
+  captureRenderTree = internalEmberModules.Debug.captureRenderTree;
+  ObjectProxy = internalEmberModules.ObjectProxy.default;
+  Observable = internalEmberModules.ObjectObservable.default;
+  Evented = internalEmberModules.ObjectEvented.default;
+  PromiseProxyMixin = internalEmberModules.ObjectPromiseProxyMixin.default;
+  Runloop = internalEmberModules.Runloop;
+  Service = internalEmberModules.Service.default;
+  EmberDestroyable = internalEmberModules.EmberDestroyable;
+  EmberObject = internalEmberModules.Object.default;
+  VERSION = internalEmberModules.VERSION.default;
+  set = internalEmberModules.Object.set;
+  get = internalEmberModules.Object.get;
+  RSVP = internalEmberModules.RSVP;
+  GlimmerComponent = internalEmberModules.GlimmerComponent;
+  GlimmerManager = internalEmberModules.GlimmerManager;
+  GlimmerReference = internalEmberModules.GlimmerReference;
+  GlimmerRuntime = internalEmberModules.GlimmerRuntime;
+  GlimmerUtil = internalEmberModules.GlimmerUtil;
+  GlimmerValidator = internalEmberModules.GlimmerValidator;
+  // owner was not available in all versions of ember that we support
+  Owner = internalEmberModules.Owner;
+}
+Debug = Debug ?? emberSafeRequire('@ember/debug');
+InternalsMetal = InternalsMetal ?? emberSafeRequire('@ember/-internals/metal');
+InternalsRuntime = InternalsRuntime ?? emberSafeRequire('@ember/-internals/runtime');
+InternalsUtils = InternalsUtils ?? emberSafeRequire('@ember/-internals/utils');
+InternalsViews = InternalsViews ?? emberSafeRequire('@ember/-internals/views');
+EmberDestroyable = EmberDestroyable ?? emberSafeRequire('@ember/destroyable');
+ObjectInternals = ObjectInternals ?? emberSafeRequire('@ember/object/internals');
+Instrumentation = Instrumentation ?? emberSafeRequire('@ember/instrumentation');
+Runloop = Runloop ?? emberSafeRequire('@ember/runloop');
+RSVP = RSVP ?? emberSafeRequire('rsvp');
+GlimmerComponent = GlimmerComponent ?? emberSafeRequire('@glimmer/component');
+GlimmerManager = GlimmerManager ?? emberSafeRequire('@glimmer/manager');
+GlimmerReference = GlimmerReference ?? emberSafeRequire('@glimmer/reference');
+GlimmerRuntime = GlimmerRuntime ?? emberSafeRequire('@glimmer/runtime');
+GlimmerUtil = GlimmerUtil ?? emberSafeRequire('@glimmer/util');
+GlimmerValidator = GlimmerValidator ?? emberSafeRequire('@glimmer/validator');
+Owner = Owner ?? emberSafeRequire('@ember/owner');
+ApplicationModule = ApplicationModule ?? emberSafeRequire('@ember/application');
+let inspect = Debug?.inspect || InternalsUtils?.inspect;
+let subscribe = Instrumentation?.subscribe;
+let cacheFor = ObjectInternals?.cacheFor;
+let guidFor = ObjectInternals?.guidFor;
+let libraries = InternalsMetal?.libraries;
+if (Ember) {
+  Application = Ember.Application;
+  Namespace = Ember.Namespace;
+  ArrayProxy = Ember.ArrayProxy;
+  MutableArray = Ember.MutableArray;
+  MutableEnumerable = Ember.MutableEnumerable;
+  NativeArray = Ember.NativeArray;
+  ControllerMixin = Ember.ControllerMixin;
+  CoreObject = Ember.CoreObject;
+  Component = Ember.Component;
+  Observable = Ember.Observable;
+  Evented = Ember.Evented;
+  PromiseProxyMixin = Ember.PromiseProxyMixin;
+  Service = Ember.Service;
+  ObjectProxy = Ember.ObjectProxy;
+  VERSION = Ember.VERSION;
+  ComputedProperty = Ember.ComputedProperty;
+  meta = Ember.meta;
+  get = Ember.get;
+  set = Ember.set;
+  computed = Ember.computed;
+  EmberObject = Ember.Object;
+  captureRenderTree = Ember._captureRenderTree;
+  getEnv = () => Ember.ENV;
+  ActionHandler = Ember.ActionHandler;
+  Debug = Debug ?? Ember.Debug;
+  inspect = inspect ?? Ember.inspect;
+  Instrumentation = Instrumentation ?? Ember.Instrumentation;
+  subscribe = subscribe ?? Ember.subscribe;
+  RSVP = RSVP ?? Ember.RSVP;
+  Runloop = Runloop ?? Ember.run;
+  cacheFor = cacheFor ?? Ember.cacheFor;
+  guidFor = guidFor ?? Ember.guidFor;
+  libraries = libraries ?? Ember.libraries;
+} else {
+  captureRenderTree = captureRenderTree ?? emberSafeRequire('@ember/debug')?.captureRenderTree;
+  getEnv = getEnv ?? emberSafeRequire('@ember/-internals/environment')?.getENV;
+  ArrayProxy = ArrayProxy ?? emberSafeRequire('@ember/array/proxy')?.default;
+  ObjectProxy = ObjectProxy ?? emberSafeRequire('@ember/object/proxy')?.default;
+  MutableArray = MutableArray ?? emberSafeRequire('@ember/array/mutable')?.default;
+  Namespace = Namespace ?? emberSafeRequire('@ember/application/namespace')?.default;
+  MutableEnumerable = MutableEnumerable ?? emberSafeRequire('@ember/enumerable/mutable')?.default;
+  NativeArray = NativeArray ?? emberSafeRequire('@ember/array')?.NativeArray;
+  ControllerMixin = ControllerMixin ?? emberSafeRequire('@ember/controller')?.ControllerMixin;
+  CoreObject = CoreObject ?? emberSafeRequire('@ember/object/core')?.default;
+  Application = Application ?? emberSafeRequire('@ember/application')?.default;
+  Component = Component ?? emberSafeRequire('@ember/component')?.default;
+  Observable = Observable ?? emberSafeRequire('@ember/object/observable')?.default;
+  Evented = Evented ?? emberSafeRequire('@ember/object/evented')?.default;
+  PromiseProxyMixin = PromiseProxyMixin ?? emberSafeRequire('@ember/object/promise-proxy-mixin')?.default;
+  Service = Service ?? emberSafeRequire('@ember/service')?.default;
+  EmberObject = EmberObject ?? emberSafeRequire('@ember/object')?.default;
+  VERSION = VERSION ?? emberSafeRequire('ember/version')?.default;
+  ComputedProperty = ComputedProperty ?? emberSafeRequire('@ember/-internals/metal')?.ComputedProperty;
+  meta = meta ?? emberSafeRequire('@ember/-internals/meta')?.meta;
+  set = set ?? emberSafeRequire('@ember/object')?.set;
+  get = get ?? emberSafeRequire('@ember/object')?.get;
+}
+if (Owner) {
+  getOwner = Owner.getOwner;
+} else {
+  getOwner = ApplicationModule?.getOwner;
+}
+
+export { ActionHandler, Application, ArrayProxy, Component, ComputedProperty, ControllerMixin, CoreObject, Debug, EmberDestroyable, EmberObject, Evented, GlimmerComponent, GlimmerManager, GlimmerReference, GlimmerRuntime, GlimmerUtil, GlimmerValidator, Instrumentation, InternalsMetal, InternalsRuntime, InternalsUtils, InternalsViews, MutableArray, MutableEnumerable, Namespace, NativeArray, ObjectInternals, ObjectProxy, Observable, PromiseProxyMixin, RSVP, Runloop, Service, VERSION, cacheFor, captureRenderTree, computed, emberSafeRequire, get, getEnv, getOwner, guidFor, inspect, libraries, meta, set, subscribe };