ember-source 6.12.0-beta.3 → 7.0.0-alpha.1

package/dist/prod/packages/@ember/instrumentation/index.js

@@ -0,0 +1,242 @@
+import { ENV } from '../-internals/environment/index.js';
+
+/* eslint no-console:off */
+/* global console */
+
+/**
+@module @ember/instrumentation
+@private
+*/
+
+/**
+  The purpose of the Ember Instrumentation module is
+  to provide efficient, general-purpose instrumentation
+  for Ember.
+
+  Subscribe to a listener by using `subscribe`:
+
+  ```javascript
+  import { subscribe } from '@ember/instrumentation';
+
+  subscribe("render", {
+    before(name, timestamp, payload) {
+
+    },
+
+    after(name, timestamp, payload) {
+
+    }
+  });
+  ```
+
+  If you return a value from the `before` callback, that same
+  value will be passed as a fourth parameter to the `after`
+  callback.
+
+  Instrument a block of code by using `instrument`:
+
+  ```javascript
+  import { instrument } from '@ember/instrumentation';
+
+  instrument("render.handlebars", payload, function() {
+    // rendering logic
+  }, binding);
+  ```
+
+  Event names passed to `instrument` are namespaced
+  by periods, from more general to more specific. Subscribers
+  can listen for events by whatever level of granularity they
+  are interested in.
+
+  In the above example, the event is `render.handlebars`,
+  and the subscriber listened for all events beginning with
+  `render`. It would receive callbacks for events named
+  `render`, `render.handlebars`, `render.container`, or
+  even `render.handlebars.layout`.
+
+  @class Instrumentation
+  @static
+  @private
+*/
+let subscribers = [];
+let cache = {};
+function populateListeners(name) {
+  let listeners = [];
+  for (let subscriber of subscribers) {
+    if (subscriber.regex.test(name)) {
+      listeners.push(subscriber.object);
+    }
+  }
+  cache[name] = listeners;
+  return listeners;
+}
+const time = () => performance.now();
+function isCallback(value) {
+  return typeof value === 'function';
+}
+
+/**
+  Notifies event's subscribers, calls `before` and `after` hooks.
+
+  @method instrument
+  @for @ember/instrumentation
+  @static
+  @param {String} [name] Namespaced event name.
+  @param {Object} payload
+  @param {Function} callback Function that you're instrumenting.
+  @param {Object} binding Context that instrument function is called with.
+  @private
+*/
+
+function instrument(name, p1, p2, p3) {
+  let _payload;
+  let callback;
+  let binding;
+  if (arguments.length <= 3 && isCallback(p1)) {
+    callback = p1;
+    binding = p2;
+  } else {
+    _payload = p1;
+    callback = p2;
+    binding = p3;
+  }
+
+  // fast path
+  if (subscribers.length === 0) {
+    return callback.call(binding);
+  }
+
+  // avoid allocating the payload in fast path
+  let payload = _payload || {};
+  let finalizer = _instrumentStart(name, () => payload);
+  if (finalizer === NOOP) {
+    return callback.call(binding);
+  } else {
+    return withFinalizer(callback, finalizer, payload, binding);
+  }
+}
+function flaggedInstrument(_name, _payload, callback) {
+  return callback();
+}
+function withFinalizer(callback, finalizer, payload, binding) {
+  try {
+    return callback.call(binding);
+  } catch (e) {
+    payload.exception = e;
+    throw e;
+  } finally {
+    finalizer();
+  }
+}
+function NOOP() {}
+
+// private for now
+
+function _instrumentStart(name, payloadFunc, payloadArg) {
+  if (subscribers.length === 0) {
+    return NOOP;
+  }
+  let listeners = cache[name];
+  if (!listeners) {
+    listeners = populateListeners(name);
+  }
+  if (listeners.length === 0) {
+    return NOOP;
+  }
+  let payload = payloadFunc(payloadArg);
+  let STRUCTURED_PROFILE = ENV.STRUCTURED_PROFILE;
+  let timeName;
+  if (STRUCTURED_PROFILE) {
+    timeName = `${name}: ${payload.object}`;
+    console.time(timeName);
+  }
+  let beforeValues = [];
+  let timestamp = time();
+  for (let listener of listeners) {
+    beforeValues.push(listener.before(name, timestamp, payload));
+  }
+  const constListeners = listeners;
+  return function _instrumentEnd() {
+    let timestamp = time();
+    for (let i = 0; i < constListeners.length; i++) {
+      let listener = constListeners[i];
+      if (typeof listener.after === 'function') {
+        listener.after(name, timestamp, payload, beforeValues[i]);
+      }
+    }
+    if (STRUCTURED_PROFILE) {
+      console.timeEnd(timeName);
+    }
+  };
+}
+
+/**
+  Subscribes to a particular event or instrumented block of code.
+
+  @method subscribe
+  @for @ember/instrumentation
+  @static
+
+  @param {String} [pattern] Namespaced event name.
+  @param {Object} [object] Before and After hooks.
+
+  @return {Subscriber}
+  @private
+*/
+function subscribe(pattern, object) {
+  let paths = pattern.split('.');
+  let regexes = [];
+  for (let path of paths) {
+    if (path === '*') {
+      regexes.push('[^\\.]*');
+    } else {
+      regexes.push(path);
+    }
+  }
+  let regex = regexes.join('\\.');
+  regex = `${regex}(\\..*)?`;
+  let subscriber = {
+    pattern,
+    regex: new RegExp(`^${regex}$`),
+    object
+  };
+  subscribers.push(subscriber);
+  cache = {};
+  return subscriber;
+}
+
+/**
+  Unsubscribes from a particular event or instrumented block of code.
+
+  @method unsubscribe
+  @for @ember/instrumentation
+  @static
+
+  @param {Object} [subscriber]
+  @private
+*/
+function unsubscribe(subscriber) {
+  let index = 0;
+  for (let i = 0; i < subscribers.length; i++) {
+    if (subscribers[i] === subscriber) {
+      index = i;
+    }
+  }
+  subscribers.splice(index, 1);
+  cache = {};
+}
+
+/**
+  Resets `Instrumentation` by flushing list of subscribers.
+
+  @method reset
+  @for @ember/instrumentation
+  @static
+  @private
+*/
+function reset() {
+  subscribers.length = 0;
+  cache = {};
+}
+
+export { _instrumentStart, flaggedInstrument, instrument, reset, subscribe, subscribers, unsubscribe };

package/dist/prod/packages/@ember/modifier/index.js

@@ -0,0 +1,21 @@
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+import { setModifierManager as setModifierManager$1 } from '../../@glimmer/manager/index.js';
+export { modifierCapabilities as capabilities } from '../../@glimmer/manager/index.js';
+export { on } from './on.js';
+import '../../shared-chunks/fragment-EpVz5Xuc.js';
+import '../../shared-chunks/index-CSVCFS_p.js';
+import '../../shared-chunks/index-DZLHQAlb.js';
+import '../-internals/container/index.js';
+import '../../shared-chunks/super-Cm_a_cLQ.js';
+import '../-internals/environment/index.js';
+import '../../shared-chunks/on-CrTl7JQU.js';
+import '../../shared-chunks/constants-b-2IVErl.js';
+import '../runloop/index.js';
+
+// NOTE: this uses assignment to *require* that the `glimmerSetModifierManager`
+// is legally assignable to this type, i.e. that variance is properly upheld.
+const setModifierManager = setModifierManager$1;
+
+export { setModifierManager };

package/dist/prod/packages/@ember/modifier/on.js

@@ -0,0 +1,20 @@
+import '../../shared-chunks/fragment-EpVz5Xuc.js';
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import { q as on$1 } from '../../shared-chunks/on-CrTl7JQU.js';
+import '../../shared-chunks/constants-b-2IVErl.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+
+// In normal TypeScript, this modifier is essentially an opaque token that just
+// needs to be importable. Declaring it with a unique interface like this,
+// however, gives tools like Glint (that *do* have a richer notion of what it
+// is) a place to install more detailed type information.
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+
+// SAFETY: at the time of writing, the cast here is from `{}` to `OnModifier`,
+// which makes it strictly safer to use outside this module because it is not
+// usable as "any non-null item", which is what `{}` means, without loss of any
+// information from the type itself.
+const on = on$1;
+
+export { on };

package/dist/prod/packages/@ember/object/-internals.js

@@ -0,0 +1,28 @@
+export { g as guidFor } from '../../shared-chunks/super-Cm_a_cLQ.js';
+import '../-internals/environment/index.js';
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+import '../../shared-chunks/observers-R1ZklwWy.js';
+export { g as cacheFor } from '../../shared-chunks/computed_cache-DmYKevAP.js';
+import EmberObject from './index.js';
+
+// Here we have runtime shenanigans to add debug-only errors to the class in dev
+// builds. Those runtime shenanigans produce the need for type-level shenanigans
+// to match: if we just assign without an explicit type annotation on the `let`
+// binding below for `FrameworkObject`, TS gets stuck because this creates
+// `FrameworkObject` with a class expression (rather than the usual class
+// declaration form). That in turn means TS needs to be able to fully name the
+// type produced by the class expression, which includes the `OWNER` symbol from
+// `@glimmer/owner`.
+//
+// By explicitly giving the declaration a type when assigning it the class
+// expression, instead of relying on inference, TS no longer needs to name the
+// `OWNER` property key from the super class, eliminating the private name
+// shenanigans.
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+
+let FrameworkObject = class FrameworkObject extends EmberObject {};
+
+export { FrameworkObject };

package/dist/prod/packages/@ember/object/compat.js

@@ -0,0 +1,128 @@
+import '../../shared-chunks/super-Cm_a_cLQ.js';
+import '../-internals/environment/index.js';
+import { tagFor, track, updateTag as UPDATE_TAG, consumeTag } from '../../@glimmer/validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+import { s as setClassicDecorator, i as isElementDescriptor } from '../../shared-chunks/decorator-BdDDBUd2.js';
+import '../../shared-chunks/observers-R1ZklwWy.js';
+
+let wrapGetterSetter = function (target, key, desc) {
+  let {
+    get: originalGet
+  } = desc;
+  if (originalGet !== undefined) {
+    desc.get = function () {
+      let propertyTag = tagFor(this, key);
+      let ret;
+      let tag = track(() => {
+        ret = originalGet.call(this);
+      });
+      UPDATE_TAG(propertyTag, tag);
+      consumeTag(tag);
+      return ret;
+    };
+  }
+  return desc;
+};
+
+/**
+  `@dependentKeyCompat` is decorator that can be used on _native getters_ that
+  use tracked properties. It exposes the getter to Ember's classic computed
+  property and observer systems, so they can watch it for changes. It can be
+  used in both native and classic classes.
+
+  Native Example:
+
+  ```js
+  import { tracked } from '@glimmer/tracking';
+  import { dependentKeyCompat } from '@ember/object/compat';
+  import { computed, set } from '@ember/object';
+
+  class Person {
+    @tracked firstName;
+    @tracked lastName;
+
+    @dependentKeyCompat
+    get fullName() {
+      return `${this.firstName} ${this.lastName}`;
+    }
+  }
+
+  class Profile {
+    constructor(person) {
+      set(this, 'person', person);
+    }
+
+    @computed('person.fullName')
+    get helloMessage() {
+      return `Hello, ${this.person.fullName}!`;
+    }
+  }
+  ```
+
+  Classic Example:
+
+  ```js
+  import { tracked } from '@glimmer/tracking';
+  import { dependentKeyCompat } from '@ember/object/compat';
+  import EmberObject, { computed, observer, set } from '@ember/object';
+
+  const Person = EmberObject.extend({
+    firstName: tracked(),
+    lastName: tracked(),
+
+    fullName: dependentKeyCompat(function() {
+      return `${this.firstName} ${this.lastName}`;
+    }),
+  });
+
+  const Profile = EmberObject.extend({
+    person: null,
+
+    helloMessage: computed('person.fullName', function() {
+      return `Hello, ${this.person.fullName}!`;
+    }),
+
+    onNameUpdated: observer('person.fullName', function() {
+      console.log('person name updated!');
+    }),
+  });
+  ```
+
+  `dependentKeyCompat()` can receive a getter function or an object containing
+  `get`/`set` methods when used in classic classes, like computed properties.
+
+  In general, only properties which you _expect_ to be watched by older,
+  untracked clases should be marked as dependency compatible. The decorator is
+  meant as an interop layer for parts of Ember's older classic APIs, and should
+  not be applied to every possible getter/setter in classes. The number of
+  dependency compatible getters should be _minimized_ wherever possible. New
+  application code should not need to use `@dependentKeyCompat`, since it is
+  only for interoperation with older code.
+
+  @public
+  @method dependentKeyCompat
+  @for @ember/object/compat
+  @static
+  @param {PropertyDescriptor|undefined} desc A property descriptor containing
+                                             the getter and setter (when used in
+                                             classic classes)
+  @return {PropertyDecorator} property decorator instance
+ */
+
+function dependentKeyCompat(...args) {
+  if (isElementDescriptor(args)) {
+    let [target, key, desc] = args;
+    return wrapGetterSetter(target, key, desc);
+  } else {
+    const desc = args[0];
+    let decorator = function (target, key, _desc, _meta, isClassicDecorator) {
+      return wrapGetterSetter(target, key, desc);
+    };
+    setClassicDecorator(decorator);
+    return decorator;
+  }
+}
+setClassicDecorator(dependentKeyCompat);
+
+export { dependentKeyCompat };

package/dist/prod/packages/@ember/object/computed.js

@@ -0,0 +1,10 @@
+export { C as default, e as expandProperties } from '../../shared-chunks/namespace_search-Aog9nySA.js';
+import '../../shared-chunks/super-Cm_a_cLQ.js';
+import '../-internals/environment/index.js';
+export { a as alias } from '../../shared-chunks/alias-BkT-0B1G.js';
+import '../../shared-chunks/observers-R1ZklwWy.js';
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+export { and, bool, deprecatingAlias, empty, equal, gt, gte, lt, lte, match, none, not, notEmpty, oneWay, or, readOnly, oneWay as reads } from './lib/computed/computed_macros.js';
+export { collect, filter, filterBy, intersect, map, mapBy, max, min, setDiff, sort, sum, union, uniq, uniqBy } from './lib/computed/reduce_computed_macros.js';