ember-source 7.4.0-alpha.1 → 7.4.0-beta.1

package/dist/dev/packages/@ember/object/mixin.js

@@ -1,593 +1,12 @@
-import { I as INIT_FACTORY } from '../../shared-chunks/container-BzzHmCNj.js';
-import { peekMeta, meta } from '../-internals/meta/lib/meta.js';
-import { R as ROOT, o as observerListenerMetaFor, w as wrap } from '../../shared-chunks/super-BBBjgF69.js';
+import '../../shared-chunks/container-BzzHmCNj.js';
+import '../-internals/meta/lib/meta.js';
+import '../../shared-chunks/super-BBBjgF69.js';
+export { a as applyMixin, M as default, m as mixin } from '../../shared-chunks/mixin-M88Ghbyw.js';
 import '../debug/index.js';
-import { n as nativeDescDecorator, a as isClassicDecorator, b as descriptorForDecorator, m as makeComputedDecorator } from '../../shared-chunks/decorator-B5Uh5NFI.js';
-import { g as defineValue, h as defineDecorator, C as ComputedProperty } from '../../shared-chunks/computed-DGxbeUbf.js';
-import { s as setUnprocessedMixins } from '../../shared-chunks/namespace_search-BfvzEQzN.js';
-import { c as revalidateObservers, b as addObserver, r as removeObserver } from '../../shared-chunks/observers-DMlX2nCi.js';
-import { a as addListener, r as removeListener } from '../../shared-chunks/events-6aFVjD4k.js';
-import { assert } from '../debug/lib/assert.js';
-
-/**
-@module @ember/object/mixin
-*/
-const a_concat = Array.prototype.concat;
-const {
-  isArray
-} = Array;
-function extractAccessors(properties) {
-  if (properties !== undefined) {
-    for (let key of Object.keys(properties)) {
-      let desc = Object.getOwnPropertyDescriptor(properties, key);
-      if (desc.get !== undefined || desc.set !== undefined) {
-        Object.defineProperty(properties, key, {
-          value: nativeDescDecorator(desc)
-        });
-      }
-    }
-  }
-  return properties;
-}
-function concatenatedMixinProperties(concatProp, props, values, base) {
-  // reset before adding each new mixin to pickup concats from previous
-  let concats = values[concatProp] || base[concatProp];
-  if (props[concatProp]) {
-    concats = concats ? a_concat.call(concats, props[concatProp]) : props[concatProp];
-  }
-  return concats;
-}
-function giveDecoratorSuper(key, decorator, property, descs) {
-  if (property === true) {
-    return decorator;
-  }
-  let originalGetter = property._getter;
-  if (originalGetter === undefined) {
-    return decorator;
-  }
-  let superDesc = descs[key];
-
-  // Check to see if the super property is a decorator first, if so load its descriptor
-  let superProperty = typeof superDesc === 'function' ? descriptorForDecorator(superDesc) : superDesc;
-  if (superProperty === undefined || superProperty === true) {
-    return decorator;
-  }
-  let superGetter = superProperty._getter;
-  if (superGetter === undefined) {
-    return decorator;
-  }
-  let get = wrap(originalGetter, superGetter);
-  let set;
-  let originalSetter = property._setter;
-  let superSetter = superProperty._setter;
-  if (superSetter !== undefined) {
-    if (originalSetter !== undefined) {
-      set = wrap(originalSetter, superSetter);
-    } else {
-      // If the super property has a setter, we default to using it no matter what.
-      // This is clearly very broken and weird, but it's what was here so we have
-      // to keep it until the next major at least.
-      //
-      // TODO: Add a deprecation here.
-      set = superSetter;
-    }
-  } else {
-    set = originalSetter;
-  }
-
-  // only create a new CP if we must
-  if (get !== originalGetter || set !== originalSetter) {
-    // Since multiple mixins may inherit from the same parent, we need
-    // to clone the computed property so that other mixins do not receive
-    // the wrapped version.
-    let dependentKeys = property._dependentKeys || [];
-    let newProperty = new ComputedProperty([...dependentKeys, {
-      get,
-      set
-    }]);
-    newProperty._readOnly = property._readOnly;
-    newProperty._meta = property._meta;
-    newProperty.enumerable = property.enumerable;
-
-    // SAFETY: We passed in the impl for this class
-    return makeComputedDecorator(newProperty, ComputedProperty);
-  }
-  return decorator;
-}
-function giveMethodSuper(key, method, values, descs) {
-  // Methods overwrite computed properties, and do not call super to them.
-  if (descs[key] !== undefined) {
-    return method;
-  }
-
-  // Find the original method in a parent mixin
-  let superMethod = values[key];
-
-  // Only wrap the new method if the original method was a function
-  if (typeof superMethod === 'function') {
-    return wrap(method, superMethod);
-  }
-  return method;
-}
-function simpleMakeArray(value) {
-  if (!value) {
-    return [];
-  } else if (!Array.isArray(value)) {
-    return [value];
-  } else {
-    return value;
-  }
-}
-function applyConcatenatedProperties(key, value, values) {
-  let baseValue = values[key];
-  let ret = simpleMakeArray(baseValue).concat(simpleMakeArray(value));
-  {
-    // it is possible to use concatenatedProperties with strings (which cannot be frozen)
-    // only freeze objects...
-    if (typeof ret === 'object' && ret !== null) {
-      // prevent mutating `concatenatedProperties` array after it is applied
-      Object.freeze(ret);
-    }
-  }
-  return ret;
-}
-function applyMergedProperties(key, value, values) {
-  let baseValue = values[key];
-  (!(!isArray(value)) && assert(`You passed in \`${JSON.stringify(value)}\` as the value for \`${key}\` but \`${key}\` cannot be an Array`, !isArray(value)));
-  if (!baseValue) {
-    return value;
-  }
-  let newBase = Object.assign({}, baseValue);
-  let hasFunction = false;
-  let props = Object.keys(value);
-  for (let prop of props) {
-    let propValue = value[prop];
-    if (typeof propValue === 'function') {
-      hasFunction = true;
-      newBase[prop] = giveMethodSuper(prop, propValue, baseValue, {});
-    } else {
-      newBase[prop] = propValue;
-    }
-  }
-  if (hasFunction) {
-    newBase._super = ROOT;
-  }
-  return newBase;
-}
-function mergeMixins(mixins, meta, descs, values, base, keys, keysWithSuper) {
-  let currentMixin;
-  for (let i = 0; i < mixins.length; i++) {
-    currentMixin = mixins[i];
-    (!(typeof currentMixin === 'object' && currentMixin !== null && Object.prototype.toString.call(currentMixin) !== '[object Array]') && assert(`Expected hash or Mixin instance, got ${Object.prototype.toString.call(currentMixin)}`, typeof currentMixin === 'object' && currentMixin !== null && Object.prototype.toString.call(currentMixin) !== '[object Array]'));
-    if (MIXINS.has(currentMixin)) {
-      if (meta.hasMixin(currentMixin)) {
-        continue;
-      }
-      meta.addMixin(currentMixin);
-      let {
-        properties,
-        mixins
-      } = currentMixin;
-      if (properties !== undefined) {
-        mergeProps(meta, properties, descs, values, base, keys, keysWithSuper);
-      } else if (mixins !== undefined) {
-        mergeMixins(mixins, meta, descs, values, base, keys, keysWithSuper);
-        if (currentMixin instanceof Mixin && currentMixin._without !== undefined) {
-          currentMixin._without.forEach(keyName => {
-            // deleting the key means we won't process the value
-            let index = keys.indexOf(keyName);
-            if (index !== -1) {
-              keys.splice(index, 1);
-            }
-          });
-        }
-      }
-    } else {
-      mergeProps(meta, currentMixin, descs, values, base, keys, keysWithSuper);
-    }
-  }
-}
-function mergeProps(meta, props, descs, values, base, keys, keysWithSuper) {
-  let concats = concatenatedMixinProperties('concatenatedProperties', props, values, base);
-  let mergings = concatenatedMixinProperties('mergedProperties', props, values, base);
-  let propKeys = Object.keys(props);
-  for (let key of propKeys) {
-    let value = props[key];
-    if (value === undefined) continue;
-    if (keys.indexOf(key) === -1) {
-      keys.push(key);
-      let desc = meta.peekDescriptors(key);
-      if (desc === undefined) {
-        // If the value is a classic decorator, we don't want to actually
-        // access it, because that will execute the decorator while we're
-        // building the class.
-        if (!isClassicDecorator(value)) {
-          // The superclass did not have a CP, which means it may have
-          // observers or listeners on that property.
-          let prev = values[key] = base[key];
-          if (typeof prev === 'function') {
-            updateObserversAndListeners(base, key, prev, false);
-          }
-        }
-      } else {
-        descs[key] = desc;
-
-        // The super desc will be overwritten on descs, so save off the fact that
-        // there was a super so we know to Object.defineProperty when writing
-        // the value
-        keysWithSuper.push(key);
-        desc.teardown(base, key, meta);
-      }
-    }
-    let isFunction = typeof value === 'function';
-    if (isFunction) {
-      let desc = descriptorForDecorator(value);
-      if (desc !== undefined) {
-        // Wrap descriptor function to implement _super() if needed
-        descs[key] = giveDecoratorSuper(key, value, desc, descs);
-        values[key] = undefined;
-        continue;
-      }
-    }
-    if (concats && concats.indexOf(key) >= 0 || key === 'concatenatedProperties' || key === 'mergedProperties') {
-      value = applyConcatenatedProperties(key, value, values);
-    } else if (mergings && mergings.indexOf(key) > -1) {
-      value = applyMergedProperties(key, value, values);
-    } else if (isFunction) {
-      value = giveMethodSuper(key, value, values, descs);
-    }
-    values[key] = value;
-    descs[key] = undefined;
-  }
-}
-function updateObserversAndListeners(obj, key, fn, add) {
-  let meta = observerListenerMetaFor(fn);
-  if (meta === undefined) return;
-  let {
-    observers,
-    listeners
-  } = meta;
-  if (observers !== undefined) {
-    let updateObserver = add ? addObserver : removeObserver;
-    for (let path of observers.paths) {
-      updateObserver(obj, path, null, key, observers.sync);
-    }
-  }
-  if (listeners !== undefined) {
-    let updateListener = add ? addListener : removeListener;
-    for (let listener of listeners) {
-      updateListener(obj, listener, null, key);
-    }
-  }
-}
-function applyMixin(obj, mixins, _hideKeys = false) {
-  let descs = Object.create(null);
-  let values = Object.create(null);
-  let meta$1 = meta(obj);
-  let keys = [];
-  let keysWithSuper = [];
-  obj._super = ROOT;
-
-  // Go through all mixins and hashes passed in, and:
-  //
-  // * Handle concatenated properties
-  // * Handle merged properties
-  // * Set up _super wrapping if necessary
-  // * Set up computed property descriptors
-  // * Copying `toString` in broken browsers
-  mergeMixins(mixins, meta$1, descs, values, obj, keys, keysWithSuper);
-  for (let key of keys) {
-    let value = values[key];
-    let desc = descs[key];
-    if (value !== undefined) {
-      if (typeof value === 'function') {
-        updateObserversAndListeners(obj, key, value, true);
-      }
-      defineValue(obj, key, value, keysWithSuper.indexOf(key) !== -1, !_hideKeys);
-    } else if (desc !== undefined) {
-      defineDecorator(obj, key, desc, meta$1);
-    }
-  }
-  if (!meta$1.isPrototypeMeta(obj)) {
-    revalidateObservers(obj);
-  }
-  return obj;
-}
-
-/**
-  @method mixin
-  @param obj
-  @param mixins*
-  @return obj
-  @private
-*/
-function mixin(obj, ...args) {
-  applyMixin(obj, args);
-  return obj;
-}
-const MIXINS = new WeakSet();
-
-/**
-  The `Mixin` class allows you to create mixins, whose properties can be
-  added to other classes. For instance,
-
-  ```javascript
-  import Mixin from '@ember/object/mixin';
-
-  const EditableMixin = Mixin.create({
-    edit() {
-      console.log('starting to edit');
-      this.set('isEditing', true);
-    },
-    isEditing: false
-  });
-  ```
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  import EditableMixin from '../mixins/editable';
-
-  // Mix mixins into classes by passing them as the first arguments to
-  // `.extend.`
-  class Comment extends EmberObject.extend(EditableMixin) {
-    post = null
-  }
-
-  let comment = Comment.create({
-    post: somePost
-  });
-
-  comment.edit(); // outputs 'starting to edit'
-  ```
-
-  Note that Mixins are created with `Mixin.create`, not
-  `Mixin.extend`.
-
-  Note that mixins extend a constructor's prototype so arrays and object literals
-  defined as properties will be shared amongst objects that implement the mixin.
-  If you want to define a property in a mixin that is not shared, you can define
-  it either as a computed property or have it be created on initialization of the object.
-
-  ```javascript
-  // filters array will be shared amongst any object implementing mixin
-  import Mixin from '@ember/object/mixin';
-  import { A } from '@ember/array';
-
-  const FilterableMixin = Mixin.create({
-    filters: A()
-  });
-  ```
-
-  ```javascript
-  import Mixin from '@ember/object/mixin';
-  import { A } from '@ember/array';
-  import { computed } from '@ember/object';
-
-  // filters will be a separate array for every object implementing the mixin
-  const FilterableMixin = Mixin.create({
-    filters: computed(function() {
-      return A();
-    })
-  });
-  ```
-
-  ```javascript
-  import Mixin from '@ember/object/mixin';
-  import { A } from '@ember/array';
-
-  // filters will be created as a separate array during the object's initialization
-  const Filterable = Mixin.create({
-    filters: null,
-
-    init() {
-      this._super(...arguments);
-      this.set("filters", A());
-    }
-  });
-  ```
-
-  @class Mixin
-  @public
-*/
-class Mixin {
-  /** @internal */
-
-  /** @internal */
-  mixins;
-
-  /** @internal */
-  properties;
-
-  /** @internal */
-  ownerConstructor;
-
-  /** @internal */
-  _without;
-  /** @internal */
-  constructor(mixins, properties) {
-    MIXINS.add(this);
-    this.properties = extractAccessors(properties);
-    this.mixins = buildMixinsArray(mixins);
-    this.ownerConstructor = undefined;
-    this._without = undefined;
-    {
-      // Eagerly add INIT_FACTORY to avoid issues in DEBUG as a result of Object.seal(mixin)
-      this[INIT_FACTORY] = null;
-      if (Mixin._disableDebugSeal !== true) {
-        Object.seal(this);
-      }
-    }
-  }
-
-  /**
-    @method create
-    @for @ember/object/mixin
-    @static
-    @param arguments*
-    @public
-  */
-  static create(...args) {
-    setUnprocessedMixins();
-    let M = this;
-    return new M(args, undefined);
-  }
-
-  // returns the mixins currently applied to the specified object
-  // TODO: Make `mixin`
-  /** @internal */
-  static mixins(obj) {
-    let meta = peekMeta(obj);
-    let ret = [];
-    if (meta === null) {
-      return ret;
-    }
-    meta.forEachMixins(currentMixin => {
-      // skip primitive mixins since these are always anonymous
-      if (!currentMixin.properties) {
-        ret.push(currentMixin);
-      }
-    });
-    return ret;
-  }
-
-  /**
-    @method reopen
-    @param arguments*
-    @private
-    @internal
-  */
-  reopen(...args) {
-    if (args.length === 0) {
-      return this;
-    }
-    if (this.properties) {
-      let currentMixin = new Mixin(undefined, this.properties);
-      this.properties = undefined;
-      this.mixins = [currentMixin];
-    } else if (!this.mixins) {
-      this.mixins = [];
-    }
-    this.mixins = this.mixins.concat(buildMixinsArray(args));
-    return this;
-  }
-
-  /**
-    @method apply
-    @param obj
-    @return applied object
-    @private
-    @internal
-  */
-  apply(obj, _hideKeys = false) {
-    // Ember.NativeArray is a normal Ember.Mixin that we mix into `Array.prototype` when prototype extensions are enabled
-    // mutating a native object prototype like this should _not_ result in enumerable properties being added (or we have significant
-    // issues with things like deep equality checks from test frameworks, or things like jQuery.extend(true, [], [])).
-    //
-    // _hideKeys disables enumerablity when applying the mixin. This is a hack, and we should stop mutating the array prototype by default 😫
-    return applyMixin(obj, [this], _hideKeys);
-  }
-
-  /** @internal */
-  applyPartial(obj) {
-    return applyMixin(obj, [this]);
-  }
-
-  /**
-    @method detect
-    @param obj
-    @return {Boolean}
-    @private
-    @internal
-  */
-  detect(obj) {
-    if (typeof obj !== 'object' || obj === null) {
-      return false;
-    }
-    if (MIXINS.has(obj)) {
-      return _detect(obj, this);
-    }
-    let meta = peekMeta(obj);
-    if (meta === null) {
-      return false;
-    }
-    return meta.hasMixin(this);
-  }
-
-  /** @internal */
-  without(...args) {
-    let ret = new Mixin([this]);
-    ret._without = args;
-    return ret;
-  }
-
-  /** @internal */
-  keys() {
-    let keys = _keys(this);
-    (!(keys) && assert('[BUG] Missing keys for mixin!', keys));
-    return keys;
-  }
-
-  /** @internal */
-  toString() {
-    return '(unknown mixin)';
-  }
-}
-{
-  Object.defineProperty(Mixin, '_disableDebugSeal', {
-    configurable: true,
-    enumerable: false,
-    writable: true,
-    value: false
-  });
-}
-function buildMixinsArray(mixins) {
-  let length = mixins && mixins.length || 0;
-  let m = undefined;
-  if (length > 0) {
-    m = new Array(length);
-    for (let i = 0; i < length; i++) {
-      let x = mixins[i];
-      (!(typeof x === 'object' && x !== null && Object.prototype.toString.call(x) !== '[object Array]') && assert(`Expected hash or Mixin instance, got ${Object.prototype.toString.call(x)}`, typeof x === 'object' && x !== null && Object.prototype.toString.call(x) !== '[object Array]'));
-      if (MIXINS.has(x)) {
-        m[i] = x;
-      } else {
-        m[i] = new Mixin(undefined, x);
-      }
-    }
-  }
-  return m;
-}
-{
-  Object.seal(Mixin.prototype);
-}
-function _detect(curMixin, targetMixin, seen = new Set()) {
-  if (seen.has(curMixin)) {
-    return false;
-  }
-  seen.add(curMixin);
-  if (curMixin === targetMixin) {
-    return true;
-  }
-  let mixins = curMixin.mixins;
-  if (mixins) {
-    return mixins.some(mixin => _detect(mixin, targetMixin, seen));
-  }
-  return false;
-}
-function _keys(mixin, ret = new Set(), seen = new Set()) {
-  if (seen.has(mixin)) {
-    return;
-  }
-  seen.add(mixin);
-  if (mixin.properties) {
-    let props = Object.keys(mixin.properties);
-    for (let prop of props) {
-      ret.add(prop);
-    }
-  } else if (mixin.mixins) {
-    mixin.mixins.forEach(x => _keys(x, ret, seen));
-  }
-  return ret;
-}
-
-export { applyMixin, Mixin as default, mixin };
+import '../../shared-chunks/decorator-B5Uh5NFI.js';
+import '../../shared-chunks/computed-CXIM4Sjc.js';
+import '../../shared-chunks/namespace_search-TFdmjK_a.js';
+import '../../shared-chunks/observers-BsxKjjpC.js';
+import '../../shared-chunks/events-e_Do73jh.js';
+import '../-internals/deprecations/index.js';
+import '../debug/lib/assert.js';

package/dist/dev/packages/@ember/object/observable.js

@@ -1,12 +1,12 @@
 import { peekMeta } from '../-internals/meta/lib/meta.js';
-import { h as hasListeners } from '../../shared-chunks/events-6aFVjD4k.js';
-import { n as notifyPropertyChange, a as endPropertyChanges, b as beginPropertyChanges } from '../../shared-chunks/computed-DGxbeUbf.js';
-import { r as removeObserver, b as addObserver } from '../../shared-chunks/observers-DMlX2nCi.js';
+import { h as hasListeners } from '../../shared-chunks/events-e_Do73jh.js';
+import { n as notifyPropertyChange, a as endPropertyChanges, b as beginPropertyChanges } from '../../shared-chunks/computed-CXIM4Sjc.js';
+import { r as removeObserver, b as addObserver } from '../../shared-chunks/observers-BsxKjjpC.js';
 import { g as get } from '../../shared-chunks/property_get-DXwpgTe7.js';
-import { s as set } from '../../shared-chunks/property_set-DezUwDX4.js';
+import { s as set } from '../../shared-chunks/property_set-CxxTalOq.js';
 import { g as getProperties } from '../../shared-chunks/get_properties-BlyZny5J.js';
-import { s as setProperties } from '../../shared-chunks/set_properties-BzM_irwA.js';
-import Mixin from './mixin.js';
+import { s as setProperties } from '../../shared-chunks/set_properties-KoN0q2wj.js';
+import { M as Mixin, I as INTERNAL_MIXIN_CREATE } from '../../shared-chunks/mixin-M88Ghbyw.js';
 import '../debug/index.js';
 import { assert } from '../debug/lib/assert.js';
 
@@ -86,7 +86,7 @@ import { assert } from '../debug/lib/assert.js';
   @public
 */
 
-const Observable = Mixin.create({
+const Observable = Mixin[INTERNAL_MIXIN_CREATE]({
   get(keyName) {
     return get(this, keyName);
   },

package/dist/dev/packages/@ember/object/observers.js

@@ -1 +1 @@
-export { b as addObserver, r as removeObserver } from '../../shared-chunks/observers-DMlX2nCi.js';
+export { b as addObserver, r as removeObserver } from '../../shared-chunks/observers-BsxKjjpC.js';

package/dist/dev/packages/@ember/object/promise-proxy-mixin.js

@@ -1,7 +1,8 @@
 import { g as get } from '../../shared-chunks/property_get-DXwpgTe7.js';
-import { s as setProperties } from '../../shared-chunks/set_properties-BzM_irwA.js';
-import { c as computed } from '../../shared-chunks/computed-DGxbeUbf.js';
-import Mixin from './mixin.js';
+import { s as setProperties } from '../../shared-chunks/set_properties-KoN0q2wj.js';
+import { c as computed } from '../../shared-chunks/computed-CXIM4Sjc.js';
+import { M as Mixin, I as INTERNAL_MIXIN_CREATE } from '../../shared-chunks/mixin-M88Ghbyw.js';
+import { deprecateUntil, DEPRECATIONS } from '../-internals/deprecations/index.js';
 
 /**
   @module @ember/object/promise-proxy-mixin
@@ -93,9 +94,14 @@ function tap(proxy, promise) {
 
   @class PromiseProxyMixin
   @public
+  @deprecated Use native `async`/`await` and promises directly instead.
 */
 
-const PromiseProxyMixin = Mixin.create({
+const PromiseProxyMixin = Mixin[INTERNAL_MIXIN_CREATE]({
+  init() {
+    this._super(...arguments);
+    deprecateUntil('`PromiseProxyMixin` is deprecated. Use native `async`/`await` and promises directly, tracking the loading state on your own class instead.', DEPRECATIONS.DEPRECATE_PROMISE_PROXY_MIXIN);
+  },
   reason: null,
   isPending: computed('isSettled', function () {
     return !get(this, 'isSettled');

package/dist/dev/packages/@ember/object/proxy.js

@@ -1,5 +1,6 @@
 import { FrameworkObject } from './-internals.js';
 import ProxyMixin from '../-internals/runtime/lib/mixins/-proxy.js';
+import { deprecateUntil, DEPRECATIONS } from '../-internals/deprecations/index.js';
 
 /**
 @module @ember/object/proxy
@@ -82,10 +83,16 @@ import ProxyMixin from '../-internals/runtime/lib/mixins/-proxy.js';
   @extends EmberObject
   @uses Ember.ProxyMixin
   @public
+  @deprecated Use tracked properties or a native `Proxy` instead.
 */
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-class ObjectProxy extends FrameworkObject {}
+class ObjectProxy extends FrameworkObject {
+  init(properties) {
+    super.init(properties);
+    deprecateUntil('`ObjectProxy` is deprecated. Use tracked properties or a native `Proxy` instead.', DEPRECATIONS.DEPRECATE_OBJECT_PROXY);
+  }
+}
 ObjectProxy.PrototypeMixin.reopen(ProxyMixin);
 
 export { ObjectProxy as default };

package/dist/dev/packages/@ember/renderer/index.js

@@ -1 +1 @@
-export { r as renderComponent, a as renderSettled } from '../../shared-chunks/index-Bv9SQpEx.js';
+export { r as renderComponent, a as renderSettled } from '../../shared-chunks/index-D8La4_AP.js';