ember-inspector 4.13.1-alpha.2024.8.9 → 4.13.1-alpha.2025.10.2

package/dist/firefox/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/firefox/panes-3-16-0/basic-DfbgtngO.js

@@ -0,0 +1,144 @@
+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;
+  }
+}
+
+export { BasicAdapter as B, onReady as o };

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

@@ -0,0 +1,6 @@
+import { l as loadEmberDebugInWebpage, o as onEmberReady, s as startInspector } from './start-inspector-BPAW_WLv.js';
+import { B as BasicAdapter } from './basic-DfbgtngO.js';
+import './versions.js';
+import './base-object-HAEdWjmg.js';
+
+loadEmberDebugInWebpage(() => onEmberReady(startInspector(BasicAdapter)));

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

@@ -0,0 +1,34 @@
+import { l as loadEmberDebugInWebpage, o as onEmberReady, s as startInspector } from './start-inspector-BPAW_WLv.js';
+import { B as BasicAdapter } from './basic-DfbgtngO.js';
+import './versions.js';
+import './base-object-HAEdWjmg.js';
+
+class adapter 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
+      });
+    };
+  }
+}
+
+loadEmberDebugInWebpage(() => onEmberReady(startInspector(adapter)));

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

@@ -0,0 +1,12 @@
+import { l as loadEmberDebugInWebpage, o as onEmberReady, s as startInspector } from './start-inspector-BPAW_WLv.js';
+import { W as WebExtension } from './web-extension-C3pMNVSY.js';
+import './versions.js';
+import './basic-DfbgtngO.js';
+import './base-object-HAEdWjmg.js';
+import './type-check.js';
+import './ember.js';
+import './runloop-CF-Qpqgy.js';
+
+class adapter extends WebExtension {}
+
+loadEmberDebugInWebpage(() => onEmberReady(startInspector(adapter)));

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

@@ -0,0 +1,115 @@
+/* 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 ArrayProxy, Namespace, ActionHandler, ControllerMixin, CoreObject, Application, MutableArray, MutableEnumerable, NativeArray, Component, Observable, Evented, PromiseProxyMixin, Service, ObjectProxy, VERSION, ComputedProperty, meta, get, set, computed, EmberObject, captureRenderTree, getEnv, getOwner;
+let Debug = emberSafeRequire('@ember/debug');
+let InternalsMetal = emberSafeRequire('@ember/-internals/metal');
+let InternalsRuntime = emberSafeRequire('@ember/-internals/runtime');
+let InternalsUtils = emberSafeRequire('@ember/-internals/utils');
+let InternalsViews = emberSafeRequire('@ember/-internals/views');
+let EmberDestroyable = emberSafeRequire('@ember/destroyable');
+let ObjectInternals = emberSafeRequire('@ember/object/internals');
+let Instrumentation = emberSafeRequire('@ember/instrumentation');
+let Runloop = emberSafeRequire('@ember/runloop');
+let RSVP = emberSafeRequire('rsvp');
+let GlimmerComponent = emberSafeRequire('@glimmer/component');
+let GlimmerManager = emberSafeRequire('@glimmer/manager');
+let GlimmerReference = emberSafeRequire('@glimmer/reference');
+let GlimmerRuntime = emberSafeRequire('@glimmer/runtime');
+let GlimmerUtil = emberSafeRequire('@glimmer/util');
+let GlimmerValidator = emberSafeRequire('@glimmer/validator');
+let EmberOwner = emberSafeRequire('@ember/owner');
+let EmberApplication = 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) {
+  captureRenderTree = Ember._captureRenderTree;
+  getEnv = () => Ember.ENV;
+  ArrayProxy = Ember.ArrayProxy;
+  ObjectProxy = Ember.ObjectProxy;
+  MutableArray = Ember.MutableArray;
+  Namespace = Ember.Namespace;
+  MutableEnumerable = Ember.MutableEnumerable;
+  NativeArray = Ember.NativeArray;
+  ControllerMixin = Ember.ControllerMixin;
+  CoreObject = Ember.CoreObject;
+  Application = Ember.Application;
+  Component = Ember.Component;
+  Observable = Ember.Observable;
+  Evented = Ember.Evented;
+  PromiseProxyMixin = Ember.PromiseProxyMixin;
+  Service = Ember.Service;
+  EmberObject = Ember.Object;
+  VERSION = Ember.VERSION;
+  ComputedProperty = Ember.ComputedProperty;
+  meta = Ember.meta;
+  get = Ember.get;
+  set = Ember.set;
+  computed = Ember.computed;
+  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 = emberSafeRequire('@ember/debug')?.captureRenderTree;
+  getEnv = emberSafeRequire('@ember/-internals/environment')?.getENV;
+  ArrayProxy = emberSafeRequire('@ember/array/proxy')?.default;
+  ObjectProxy = emberSafeRequire('@ember/object/proxy')?.default;
+  MutableArray = emberSafeRequire('@ember/array/mutable')?.default;
+  Namespace = emberSafeRequire('@ember/application/namespace')?.default;
+  MutableEnumerable = emberSafeRequire('@ember/enumerable/mutable')?.default;
+  NativeArray = emberSafeRequire('@ember/array')?.NativeArray;
+  ControllerMixin = emberSafeRequire('@ember/controller')?.ControllerMixin;
+  CoreObject = emberSafeRequire('@ember/object/core')?.default;
+  Application = emberSafeRequire('@ember/application')?.default;
+  Component = emberSafeRequire('@ember/component')?.default;
+  Observable = emberSafeRequire('@ember/object/observable')?.default;
+  Evented = emberSafeRequire('@ember/object/evented')?.default;
+  PromiseProxyMixin = emberSafeRequire('@ember/object/promise-proxy-mixin')?.default;
+  Service = emberSafeRequire('@ember/service')?.default;
+  EmberObject = emberSafeRequire('@ember/object')?.default;
+  VERSION = emberSafeRequire('ember/version')?.default;
+  ComputedProperty = emberSafeRequire('@ember/-internals/metal')?.ComputedProperty;
+  meta = emberSafeRequire('@ember/-internals/meta')?.meta;
+  set = emberSafeRequire('@ember/object')?.set;
+  get = emberSafeRequire('@ember/object')?.get;
+}
+if (EmberOwner) {
+  getOwner = EmberOwner.getOwner;
+} else {
+  getOwner = EmberApplication.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 };