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

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

@@ -0,0 +1,108 @@
+import { g as guidFor } from './internals-CRmXMEzb.js';
+import { r as run } from './runloop-CF-Qpqgy.js';
+import { B as BaseObject } from './base-object-HAEdWjmg.js';
+import { E as Evented } from './evented-BCTya3yE.js';
+import './ember.js';
+
+class Port extends BaseObject {
+  constructor(data) {
+    super(data);
+    Evented.applyTo(this);
+  }
+  get adapter() {
+    return this.namespace?.adapter;
+  }
+  get applicationId() {
+    return this.namespace?.applicationId;
+  }
+  get applicationName() {
+    return this.namespace?._application?.name || this.namespace?._application?.modulePrefix;
+  }
+
+  /**
+   * Unique id per application (not application instance). It's very important
+   * that this id doesn't change when the app is reset otherwise the inspector
+   * will no longer recognize the app.
+   *
+   * @property uniqueId
+   * @type {String}
+   */
+  get uniqueId() {
+    return guidFor(this.namespace?._application, 'ember');
+  }
+
+  // eslint-disable-next-line ember/classic-decorator-hooks
+  init() {
+    /**
+     * Stores the timestamp when it was first accessed.
+     *
+     * @property now
+     * @type {Number}
+     */
+    this.now = Date.now();
+    this.adapter.onMessageReceived(message => {
+      if (this.uniqueId === message.applicationId || !message.applicationId) {
+        this.messageReceived(message.type, message);
+      }
+    });
+  }
+  messageReceived(name, message) {
+    // 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 (name.startsWith('view:')) {
+      try {
+        this.trigger(name, message);
+      } catch (error) {
+        this.adapter.handleError(error);
+      }
+    } else {
+      this.wrap(() => {
+        this.trigger(name, message);
+      });
+    }
+  }
+  send(messageType, options = {}) {
+    options.type = messageType;
+    options.from = 'inspectedWindow';
+    options.applicationId = this.uniqueId;
+    options.applicationName = this.applicationName;
+    this.adapter.send(options);
+  }
+
+  /**
+   * Wrap all code triggered from outside of
+   * EmberDebug with this method.
+   *
+   * `wrap` is called by default
+   * on all callbacks triggered by `port`,
+   * so no need to call it in this case.
+   *
+   * - Wraps a callback in `Ember.run`.
+   * - Catches all errors during production
+   * and displays them in a user friendly manner.
+   *
+   * @method wrap
+   * @param {Function} fn
+   * @return {Mixed} The return value of the passed function
+   */
+  wrap(fn) {
+    return run(this, function () {
+      try {
+        return fn();
+      } catch (error) {
+        this.adapter.handleError(error);
+      }
+    });
+  }
+}
+
+export { Port as default };

package/dist/firefox/panes-3-16-0/profile-node.js

@@ -0,0 +1,60 @@
+import { g as guidFor } from './internals-CRmXMEzb.js';
+import './ember.js';
+
+/**
+  A tree structure for assembling a list of render calls so they can be grouped and displayed nicely afterwards.
+
+  @class ProfileNode
+**/
+function get(obj, key) {
+  return obj.get ? obj.get(key) : obj[key];
+}
+const ProfileNode = function (start, payload, parent, now) {
+  let name;
+  this.start = start;
+  this.timestamp = now || Date.now();
+  if (payload) {
+    if (payload.template) {
+      name = payload.template;
+    } else if (payload.view) {
+      const view = payload.view;
+      name = get(view, 'instrumentDisplay') || get(view, '_debugContainerKey');
+      if (name) {
+        name = name.replace(/^view:/, '');
+      }
+      this.viewGuid = guidFor(view);
+    }
+    if (!name && payload.object) {
+      name = payload.object.toString().replace(/:?:ember\d+>$/, '').replace(/^</, '');
+      if (!this.viewGuid) {
+        const match = name.match(/:(ember\d+)>$/);
+        if (match && match.length > 1) {
+          this.viewGuid = match[1];
+        }
+      }
+    }
+  }
+  this.name = name || 'Unknown view';
+  if (parent) {
+    this.parent = parent;
+  }
+  this.children = [];
+};
+ProfileNode.prototype = {
+  finish(timestamp) {
+    this.time = timestamp - this.start;
+    this.calcDuration();
+
+    // Once we attach to our parent, we remove that reference
+    // to avoid a graph cycle when serializing:
+    if (this.parent) {
+      this.parent.children.push(this);
+      this.parent = null;
+    }
+  },
+  calcDuration() {
+    this.duration = Math.round(this.time * 100) / 100;
+  }
+};
+
+export { ProfileNode as default };

package/dist/firefox/panes-3-16-0/promise-assembler.js

@@ -0,0 +1,218 @@
+import { a as _applyDecoratedDescriptor, B as BaseObject, b as _initializerDefineProperty, _ as _defineProperty } from './base-object-HAEdWjmg.js';
+import { typeOf } from './type-check.js';
+import { RSVP } from './ember.js';
+import { E as Evented } from './evented-BCTya3yE.js';
+
+var _dec, _dec2, _dec3, _class2, _descriptor, _descriptor2, _descriptor3;
+const dateComputed = function () {
+  return function (target, propertyKey) {
+    return {
+      get() {
+        return this[`__${propertyKey}__`];
+      },
+      set(date) {
+        if (typeOf(date) === 'date') {
+          this[`__${propertyKey}__`] = date;
+          return;
+        } else if (typeof date === 'number' || typeof date === 'string') {
+          this[`__${propertyKey}__`] = new Date(date);
+          return;
+        }
+        this[`__${propertyKey}__`] = null;
+      }
+    };
+  };
+};
+let _class = (_dec = dateComputed(), _dec2 = dateComputed(), _dec3 = dateComputed(), _class2 = class _class2 extends BaseObject {
+  constructor(...args) {
+    super(...args);
+    _initializerDefineProperty(this, "createdAt", _descriptor, this);
+    _initializerDefineProperty(this, "settledAt", _descriptor2, this);
+    _initializerDefineProperty(this, "chainedAt", _descriptor3, this);
+    _defineProperty(this, "parent", null);
+    _defineProperty(this, "children", []);
+  }
+  get level() {
+    const parent = this.parent;
+    if (!parent) {
+      return 0;
+    }
+    return parent.level + 1;
+  }
+  get isSettled() {
+    return this.isFulfilled || this.isRejected;
+  }
+  get isFulfilled() {
+    return this.state === 'fulfilled';
+  }
+  get isRejected() {
+    return this.state === 'rejected';
+  }
+}, _descriptor = _applyDecoratedDescriptor(_class2.prototype, "createdAt", [_dec], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "settledAt", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor3 = _applyDecoratedDescriptor(_class2.prototype, "chainedAt", [_dec3], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _class2);
+
+var _PromiseAssembler;
+class PromiseAssembler extends BaseObject {
+  constructor(data) {
+    super(data);
+    // RSVP lib to debug
+    _defineProperty(this, "isStarted", false);
+    Evented.applyTo(this);
+  }
+
+  // eslint-disable-next-line ember/classic-decorator-hooks
+  init() {
+    super.init();
+    this.all = [];
+    this.promiseIndex = {};
+  }
+  start() {
+    this.RSVP.configure('instrument', true);
+    this.promiseChained = e => {
+      chain.call(this, e);
+    };
+    this.promiseRejected = e => {
+      reject.call(this, e);
+    };
+    this.promiseFulfilled = e => {
+      fulfill.call(this, e);
+    };
+    this.promiseCreated = e => {
+      create.bind(this)(e);
+    };
+    this.RSVP.on('chained', this.promiseChained);
+    this.RSVP.on('rejected', this.promiseRejected);
+    this.RSVP.on('fulfilled', this.promiseFulfilled);
+    this.RSVP.on('created', this.promiseCreated);
+    this.isStarted = true;
+  }
+  stop() {
+    if (this.isStarted) {
+      this.RSVP.configure('instrument', false);
+      this.RSVP.off('chained', this.promiseChained);
+      this.RSVP.off('rejected', this.promiseRejected);
+      this.RSVP.off('fulfilled', this.promiseFulfilled);
+      this.RSVP.off('created', this.promiseCreated);
+      this.all.forEach(item => {
+        item.destroy();
+      });
+      this.all = [];
+      this.promiseIndex = {};
+      this.promiseChained = null;
+      this.promiseRejected = null;
+      this.promiseFulfilled = null;
+      this.promiseCreated = null;
+      this.isStarted = false;
+    }
+  }
+  willDestroy() {
+    this.stop();
+    super.willDestroy();
+  }
+  createPromise(props) {
+    let promise = new _class(props);
+    let index = this.all.length;
+    this.all.push(promise);
+    this.promiseIndex[promise.guid] = index;
+    return promise;
+  }
+  find(guid) {
+    if (guid) {
+      const index = this.promiseIndex[guid];
+      if (index !== undefined) {
+        return this.all[index];
+      }
+    } else {
+      return this.all;
+    }
+  }
+  findOrCreate(guid) {
+    return this.find(guid) || this.createPromise({
+      guid
+    });
+  }
+  updateOrCreate(guid, properties) {
+    let entry = this.find(guid);
+    if (entry) {
+      Object.assign(entry, properties);
+    } else {
+      properties = Object.assign({}, properties);
+      properties.guid = guid;
+      entry = this.createPromise(properties);
+    }
+    return entry;
+  }
+}
+_PromiseAssembler = PromiseAssembler;
+_PromiseAssembler.prototype.RSVP = RSVP;
+function fulfill(event) {
+  const guid = event.guid;
+  const promise = this.updateOrCreate(guid, {
+    label: event.label,
+    settledAt: event.timeStamp,
+    state: 'fulfilled',
+    value: event.detail
+  });
+  this.trigger('fulfilled', {
+    promise
+  });
+}
+function reject(event) {
+  const guid = event.guid;
+  const promise = this.updateOrCreate(guid, {
+    label: event.label,
+    settledAt: event.timeStamp,
+    state: 'rejected',
+    reason: event.detail
+  });
+  this.trigger('rejected', {
+    promise
+  });
+}
+function chain(event) {
+  let guid = event.guid;
+  let promise = this.updateOrCreate(guid, {
+    label: event.label,
+    chainedAt: event.timeStamp
+  });
+  let children = promise.children;
+  let child = this.findOrCreate(event.childGuid);
+  child.parent = promise;
+  children.push(child);
+  this.trigger('chained', {
+    promise,
+    child
+  });
+}
+function create(event) {
+  const guid = event.guid;
+  const promise = this.updateOrCreate(guid, {
+    label: event.label,
+    createdAt: event.timeStamp,
+    stack: event.stack
+  });
+
+  // todo fix ordering
+  if (!promise.state) {
+    promise.state = 'created';
+  }
+  this.trigger('created', {
+    promise
+  });
+}
+
+export { PromiseAssembler as default };