ember-source 4.1.0-alpha.6 → 4.2.0-alpha.1

package/dist/packages/@ember/-internals/runtime/lib/mixins/target_action_support.js

@@ -3,14 +3,8 @@
 */
 import { context } from '@ember/-internals/environment';
 import { get, Mixin, computed } from '@ember/-internals/metal';
-import { assert, deprecate } from '@ember/debug';
+import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
-
-if (DEBUG && true
-/* EMBER_MODERNIZED_BUILT_IN_COMPONENTS */
-) {
-  Mixin._disableDebugSeal = true;
-}
 /**
 `Ember.TargetActionSupport` is a mixin that can be included in a class
 to add a `triggerAction` method with semantics similar to the Handlebars
@@ -24,7 +18,6 @@ doing more complex event handling in Components.
 @private
 */
 
-
 const TargetActionSupport = Mixin.create({
   target: null,
   action: null,
@@ -151,41 +144,8 @@ function getTarget(instance) {
   return null;
 }
 
-if (true
-/* EMBER_MODERNIZED_BUILT_IN_COMPONENTS */
-) {
-  Object.defineProperty(TargetActionSupport, '_wasReopened', {
-    configurable: true,
-    enumerable: false,
-    writable: true,
-    value: false
-  });
-  Object.defineProperty(TargetActionSupport, 'reopen', {
-    configurable: true,
-    enumerable: false,
-    writable: true,
-    value: function reopen(...args) {
-      if (this === TargetActionSupport) {
-        deprecate('Reopening Ember.TargetActionSupport is deprecated.', false, {
-          id: 'ember.built-in-components.reopen',
-          for: 'ember-source',
-          since: {
-            enabled: '3.27.0'
-          },
-          until: '4.0.0',
-          url: 'https://deprecations.emberjs.com/v3.x#toc_ember-built-in-components-reopen'
-        });
-        TargetActionSupport._wasReopened = true;
-      }
-
-      return Mixin.prototype.reopen.call(this, ...args);
-    }
-  });
-
-  if (DEBUG) {
-    Object.seal(TargetActionSupport);
-    Mixin._disableDebugSeal = false;
-  }
+if (DEBUG) {
+  Object.seal(TargetActionSupport);
 }
 
 export default TargetActionSupport;

package/dist/packages/@ember/-internals/runtime/lib/system/array_proxy.js

@@ -1,7 +1,7 @@
 /**
 @module @ember/array
 */
-import { get, objectAt, alias, PROPERTY_DID_CHANGE, addArrayObserver, removeArrayObserver, replace, arrayContentDidChange, tagForProperty } from '@ember/-internals/metal';
+import { get, objectAt, alias, PROPERTY_DID_CHANGE, addArrayObserver, removeArrayObserver, replace, arrayContentDidChange, arrayContentWillChange, tagForProperty } from '@ember/-internals/metal';
 import { isObject } from '@ember/-internals/utils';
 import EmberObject from './object';
 import { isArray, MutableArray } from '../mixins/array';
@@ -237,11 +237,11 @@ export default class ArrayProxy extends EmberObject {
 
     this._removeArrangedContentArrayObserver();
 
-    this.arrayContentWillChange(0, oldLength, newLength);
+    arrayContentWillChange(this, 0, oldLength, newLength);
 
     this._invalidate();
 
-    this.arrayContentDidChange(0, oldLength, newLength);
+    arrayContentDidChange(this, 0, oldLength, newLength, false);
 
     this._addArrangedContentArrayObserver(arrangedContent);
   }
@@ -250,21 +250,21 @@ export default class ArrayProxy extends EmberObject {
     if (arrangedContent && !arrangedContent.isDestroyed) {
       assert("Can't set ArrayProxy's content to itself", arrangedContent !== this);
       assert(`ArrayProxy expects an Array or ArrayProxy, but you passed ${typeof arrangedContent}`, isArray(arrangedContent) || arrangedContent.isDestroyed);
-      addArrayObserver(arrangedContent, this, ARRAY_OBSERVER_MAPPING, true);
+      addArrayObserver(arrangedContent, this, ARRAY_OBSERVER_MAPPING);
       this._arrangedContent = arrangedContent;
     }
   }
 
   _removeArrangedContentArrayObserver() {
     if (this._arrangedContent) {
-      removeArrayObserver(this._arrangedContent, this, ARRAY_OBSERVER_MAPPING, true);
+      removeArrayObserver(this._arrangedContent, this, ARRAY_OBSERVER_MAPPING);
     }
   }
 
   _arrangedContentArrayWillChange() {}
 
   _arrangedContentArrayDidChange(proxy, idx, removedCnt, addedCnt) {
-    this.arrayContentWillChange(idx, removedCnt, addedCnt);
+    arrayContentWillChange(this, idx, removedCnt, addedCnt);
     let dirtyIndex = idx;
 
     if (dirtyIndex < 0) {
@@ -277,7 +277,7 @@ export default class ArrayProxy extends EmberObject {
     }
 
     this._lengthDirty = true;
-    this.arrayContentDidChange(idx, removedCnt, addedCnt);
+    arrayContentDidChange(this, idx, removedCnt, addedCnt, false);
   }
 
   _invalidate() {
@@ -324,12 +324,5 @@ ArrayProxy.reopen(MutableArray, {
      @property arrangedContent
     @public
   */
-  arrangedContent: alias('content'),
-
-  // Array proxies don't need to notify when they change since their `[]` tag is
-  // already dependent on the `[]` tag of `arrangedContent`
-  arrayContentDidChange(startIdx, removeAmt, addAmt) {
-    return arrayContentDidChange(this, startIdx, removeAmt, addAmt, false);
-  }
-
+  arrangedContent: alias('content')
 });

package/dist/packages/@ember/-internals/utils/index.js

@@ -74,9 +74,6 @@ function isObject(value) {
 */
 
 /**
- Previously we used `Ember.$.uuid`, however `$.uuid` has been removed from
- jQuery master. We'll just bootstrap our own uuid now.
-
  @private
  @return {Number} the uuid
  */

package/dist/packages/@ember/-internals/views/index.js

@@ -1,7 +1,6 @@
 export { addChildView, isSimpleClick, getViewBounds, getViewClientRects, getViewBoundingClientRect, getRootViews, getChildViews, getViewId, getElementView, getViewElement, setElementView, setViewElement, clearElementView, clearViewElement, constructStyleDeprecationMessage } from './lib/system/utils';
 export { default as EventDispatcher } from './lib/system/event_dispatcher';
 export { default as ComponentLookup } from './lib/component_lookup';
-export { default as TextSupport } from './lib/mixins/text_support';
 export { default as CoreView } from './lib/views/core_view';
 export { default as ClassNamesSupport } from './lib/mixins/class_names_support';
 export { default as ChildViewsSupport } from './lib/mixins/child_views_support';

package/dist/packages/@ember/-internals/views/lib/mixins/view_support.js

@@ -146,7 +146,7 @@ let mixin = {
    the target element you are providing is associated with an `Application`
    and does not have an ancestor element that is associated with an Ember view.
     @method appendTo
-   @param {String|DOMElement|jQuery} A selector, element, HTML string, or jQuery object
+   @param {String|DOMElement} A selector, element, HTML string
    @return {Ember.View} receiver
    @private
    */
@@ -172,8 +172,8 @@ let mixin = {
       })());
     } else {
       target = selector;
-      assert(`You tried to append to a selector string (${selector}) in an environment without jQuery`, typeof target !== 'string');
-      assert(`You tried to append to a non-Element (${selector}) in an environment without jQuery`, typeof selector.appendChild === 'function');
+      assert(`You tried to append to a selector string (${selector}) in an environment without a DOM`, typeof target !== 'string');
+      assert(`You tried to append to a non-Element (${selector}) in an environment without a DOM`, typeof selector.appendChild === 'function');
     }
 
     this.renderer.appendTo(this, target);
@@ -303,7 +303,7 @@ let mixin = {
    Component properties that depend on the presence of an outer element, such
    as `classNameBindings` and `attributeBindings`, do not work with tagless
    components. Tagless components cannot implement methods to handle events,
-   and have no associated jQuery object to return with `$()`.
+   and their `element` property has a `null` value.
     @property tagName
    @type String
    @default null

package/dist/packages/@ember/application/lib/application.js

@@ -110,7 +110,7 @@ import { RouterService } from '@ember/-internals/routing';
   });
   ```
 
-  The `rootElement` can be either a DOM element or a jQuery-compatible selector
+  The `rootElement` can be either a DOM element or a CSS selector
   string. Note that *views appended to the DOM outside the root element will
   not receive events.* If you specify a custom root element, make sure you only
   append views inside it!
@@ -174,8 +174,7 @@ import { RouterService } from '@ember/-internals/routing';
 const Application = Engine.extend({
   /**
     The root DOM element of the Application. This can be specified as an
-    element or a
-    [jQuery-compatible selector string](http://api.jquery.com/category/selectors/).
+    element or a [selector string](https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/Selectors#reference_table_of_selectors).
      This is the element that will be passed to the Application's,
     `eventDispatcher`, which sets up the listeners for event delegation. Every
     view in your application should be a child of the element you specify here.
@@ -481,10 +480,10 @@ const Application = Engine.extend({
     import Application from '@ember/application';
      let App = Application.create();
      App.deferReadiness();
-     // $ is a reference to the jQuery object/function
-    import $ from 'jquery;
-     $.getJSON('/auth-token', function(token) {
-      App.token = token;
+     fetch('/auth-token')
+    .then(response => response.json())
+    .then(data => {
+      App.token = data.token;
       App.advanceReadiness();
     });
     ```
@@ -831,7 +830,7 @@ const Application = Engine.extend({
     in the non-browser environment, the stand-in `document` object only needs to
     implement a limited subset of the full DOM API. The `SimpleDOM` library is known
     to work.
-     Since there is no access to jQuery in the non-browser environment, you must also
+     Since there is no DOM access in the non-browser environment, you must also
     specify a DOM `Element` object in the same `document` for the `rootElement` option
     (as opposed to a selector string like `"body"`).
      See the documentation on the `isBrowser`, `document` and `rootElement` properties

package/dist/packages/@ember/canary-features/index.js

@@ -16,11 +16,10 @@ export const DEFAULT_FEATURES = {
   EMBER_NAMED_BLOCKS: true,
   EMBER_GLIMMER_HELPER_MANAGER: true,
   EMBER_GLIMMER_INVOKE_HELPER: true,
-  EMBER_MODERNIZED_BUILT_IN_COMPONENTS: true,
   EMBER_STRICT_MODE: true,
   EMBER_DYNAMIC_HELPERS_AND_MODIFIERS: true,
-  EMBER_ROUTING_ROUTER_SERVICE_REFRESH: null,
-  EMBER_CACHED: null
+  EMBER_ROUTING_ROUTER_SERVICE_REFRESH: true,
+  EMBER_CACHED: true
 };
 /**
   The hash of enabled Canary features. Add to this, any canary features
@@ -74,7 +73,6 @@ export const EMBER_IMPROVED_INSTRUMENTATION = featureValue(FEATURES.EMBER_IMPROV
 export const EMBER_NAMED_BLOCKS = featureValue(FEATURES.EMBER_NAMED_BLOCKS);
 export const EMBER_GLIMMER_HELPER_MANAGER = featureValue(FEATURES.EMBER_GLIMMER_HELPER_MANAGER);
 export const EMBER_GLIMMER_INVOKE_HELPER = featureValue(FEATURES.EMBER_GLIMMER_INVOKE_HELPER);
-export const EMBER_MODERNIZED_BUILT_IN_COMPONENTS = featureValue(FEATURES.EMBER_MODERNIZED_BUILT_IN_COMPONENTS);
 export const EMBER_STRICT_MODE = featureValue(FEATURES.EMBER_STRICT_MODE);
 export const EMBER_DYNAMIC_HELPERS_AND_MODIFIERS = featureValue(FEATURES.EMBER_DYNAMIC_HELPERS_AND_MODIFIERS);
 export const EMBER_ROUTING_ROUTER_SERVICE_REFRESH = featureValue(FEATURES.EMBER_ROUTING_ROUTER_SERVICE_REFRESH);

package/dist/packages/@ember/component/index.js

@@ -1,3 +1,3 @@
 export { setComponentTemplate, getComponentTemplate } from '@glimmer/manager';
-export { Component as default, Input } from '@ember/-internals/glimmer';
+export { Component as default, Input, Textarea } from '@ember/-internals/glimmer';
 export { componentCapabilities as capabilities, setComponentManager } from '@ember/-internals/glimmer';

package/dist/packages/@ember/deprecated-features/index.js

@@ -1,5 +1,4 @@
 /* eslint-disable no-implicit-coercion */
 // These versions should be the version that the deprecation was _introduced_,
 // not the version that the feature will be removed.
-export const ROUTER_EVENTS = !!'4.0.0';
 export const ASSIGN = !!'4.0.0-beta.1';

package/dist/packages/@ember/destroyable/index.js

@@ -22,7 +22,9 @@ import { registerDestructor as _registerDestructor, unregisterDestructor as _unr
 
   ```js
   class CustomSelect extends Component {
-    constructor() {
+    constructor(...args) {
+      super(...args);
+
       // obj is now a child of the component. When the component is destroyed,
       // obj will also be destroyed, and have all of its destructors triggered.
       this.obj = associateDestroyableChild(this, {});
@@ -153,12 +155,15 @@ import { registerDestructor as _registerDestructor, unregisterDestructor as _unr
   parent is destroyed, the destructor function will be called.
 
   ```js
+  import Component from '@glimmer/component';
   import { registerDestructor } from '@ember/destroyable';
 
   class Modal extends Component {
     @service resize;
 
-    constructor() {
+    constructor(...args) {
+      super(...args);
+
       this.resize.register(this, this.layout);
 
       registerDestructor(this, () => this.resize.unregister(this));
@@ -175,6 +180,7 @@ import { registerDestructor as _registerDestructor, unregisterDestructor as _unr
   than creating a closure function per destroyable.
 
   ```js
+  import Component from '@glimmer/component';
   import { registerDestructor } from '@ember/destroyable';
 
   function unregisterResize(instance) {
@@ -184,7 +190,9 @@ import { registerDestructor as _registerDestructor, unregisterDestructor as _unr
   class Modal extends Component {
     @service resize;
 
-    constructor() {
+    constructor(...args) {
+      super(...args);
+
       this.resize.register(this, this.layout);
 
       registerDestructor(this, unregisterResize);
@@ -208,12 +216,15 @@ export function registerDestructor(destroyable, destructor) {
   from the destroyable.
 
   ```js
+  import Component from '@glimmer/component';
   import { registerDestructor, unregisterDestructor } from '@ember/destroyable';
 
   class Modal extends Component {
     @service modals;
 
-    constructor() {
+    constructor(...args) {
+      super(...args);
+
       this.modals.add(this);
 
       this.modalDestructor = registerDestructor(this, () => this.modals.remove(this));

package/dist/packages/@ember/engine/index.js

@@ -292,7 +292,6 @@ Engine.reopenClass({
     and after.
      Example instanceInitializer to preload data into the store.
      ```app/initializer/preload-data.js
-    import $ from 'jquery';
      export function initialize(application) {
         var userConfig, userConfigEncoded, store;
         // We have a HTML escaped JSON representation of the user's basic
@@ -303,7 +302,7 @@ Engine.reopenClass({
         // like all local models and data can be manipulated by the user, so it
         // should not be relied upon for security or authorization.
          // Grab the encoded data from the meta tag
-        userConfigEncoded = $('head meta[name=app-user-config]').attr('content');
+        userConfigEncoded = document.querySelector('head meta[name=app-user-config]').attr('content');
          // Unescape the text, then parse the resulting JSON into a real object
         userConfig = JSON.parse(unescape(userConfigEncoded));
          // Lookup the store

package/dist/packages/@ember/routing/index.js

@@ -1 +1 @@
-export { LinkComponent as LinkTo } from '@ember/-internals/glimmer';
+export { LinkTo } from '@ember/-internals/glimmer';

package/dist/packages/@glimmer/tracking/index.js

@@ -1 +1,203 @@
-export { tracked, cached } from '@ember/-internals/metal';
+export { tracked, cached } from '@ember/-internals/metal';
+/**
+  In order to tell Ember a value might change, we need to mark it as trackable.
+  Trackable values are values that:
+
+  - Can change over their component’s lifetime and
+  - Should cause Ember to rerender if and when they change
+
+  We can do this by marking the field with the `@tracked` decorator.
+
+  @module @glimmer/tracking
+  @public
+*/
+
+/**
+  Marks a property as tracked. By default, values that are rendered in Ember app
+  templates are _static_, meaning that updates to them won't cause the
+  application to rerender. Marking a property as tracked means that when that
+  property changes, any templates that used that property, directly or
+  indirectly, will rerender. For instance, consider this component:
+
+  ```handlebars
+  <div>Count: {{this.count}}</div>
+  <div>Times Ten: {{this.timesTen}}</div>
+  <div>
+    <button {{on "click" this.plusOne}}>
+      Plus One
+    </button>
+  </div>
+  ```
+
+  ```javascript
+  import Component from '@glimmer/component';
+  import { tracked } from '@glimmer/tracking';
+  import { action } from '@ember/object';
+
+  export default class CounterComponent extends Component {
+    @tracked count = 0;
+
+    get timesTen() {
+      return this.count * 10;
+    }
+
+    @action
+    plusOne() {
+      this.count += 1;
+    }
+  }
+  ```
+
+  Both the `{{this.count}}` and the `{{this.timesTen}}` properties in the
+  template will update whenever the button is clicked. Any tracked properties
+  that are used in any way to calculate a value that is used in the template
+  will cause a rerender when updated - this includes through method calls and
+  other means:
+
+  ```javascript
+  import Component from '@glimmer/component';
+  import { tracked } from '@glimmer/tracking';
+
+  class Entry {
+    @tracked name;
+    @tracked phoneNumber;
+
+    constructor(name, phoneNumber) {
+      this.name = name;
+      this.phoneNumber = phoneNumber;
+    }
+  }
+
+  export default class PhoneBookComponent extends Component {
+    entries = [
+      new Entry('Pizza Palace', 5551234),
+      new Entry('1st Street Cleaners', 5554321),
+      new Entry('Plants R Us', 5552468),
+    ];
+
+    // Any usage of this property will update whenever any of the names in the
+    // entries arrays are updated
+    get names() {
+      return this.entries.map(e => e.name);
+    }
+
+    // Any usage of this property will update whenever any of the numbers in the
+    // entries arrays are updated
+    get numbers() {
+      return this.getFormattedNumbers();
+    }
+
+    getFormattedNumbers() {
+      return this.entries
+        .map(e => e.phoneNumber)
+        .map(number => {
+          let numberString = '' + number;
+
+          return numberString.slice(0, 3) + '-' + numberString.slice(3);
+        });
+    }
+  }
+  ```
+
+  It's important to note that setting tracked properties will always trigger an
+  update, even if the property is set to the same value as it was before.
+
+  ```js
+  let entry = new Entry('Pizza Palace', 5551234);
+  // if entry was used when rendering, this would cause a rerender, even though
+  // the name is being set to the same value as it was before
+  entry.name = entry.name;
+  ```
+
+  `tracked` can also be used with the classic Ember object model in a similar
+  manner to classic computed properties:
+
+  ```javascript
+  import EmberObject from '@ember/object';
+  import { tracked } from '@glimmer/tracking';
+
+  const Entry = EmberObject.extend({
+    name: tracked(),
+    phoneNumber: tracked()
+  });
+  ```
+
+  Often this is unnecessary, but to ensure robust auto-tracking behavior it is
+  advisable to mark tracked state appropriately wherever possible.
+  This form of `tracked` also accepts an optional configuration object
+  containing either an initial `value` or an `initializer` function (but not
+  both).
+
+  ```javascript
+  import EmberObject from '@ember/object';
+  import { tracked } from '@glimmer/tracking';
+
+  const Entry = EmberObject.extend({
+    name: tracked({ value: 'Zoey' }),
+    favoriteSongs: tracked({
+      initializer: () => ['Raspberry Beret', 'Time After Time']
+    })
+  });
+  ```
+
+  @method tracked
+  @static
+  @for @glimmer/tracking
+  @public
+*/
+
+/**
+  The `@cached` decorator can be used on getters in order to cache the return
+  value of the getter. This is useful when a getter is expensive and used very
+  often. For instance, in this guest list class, we have the `sortedGuests`
+  getter that sorts the guests alphabetically:
+
+  ```js
+  import { tracked } from '@glimmer/tracking';
+
+  class GuestList {
+    @tracked guests = ['Zoey', 'Tomster'];
+
+    get sortedGuests() {
+      return this.guests.slice().sort()
+    }
+  }
+  ```
+
+  Every time `sortedGuests` is accessed, a new array will be created and sorted,
+  because JavaScript getters do not cache by default. When the guest list is
+  small, like the one in the example, this is not a problem. However, if the guest
+  list were to grow very large, it would mean that we would be doing a large
+  amount of work each time we accessed `sortedGetters`. With `@cached`, we can
+  cache the value instead:
+
+  ```js
+  import { tracked, cached } from '@glimmer/tracking';
+
+  class GuestList {
+    @tracked guests = ['Zoey', 'Tomster'];
+
+    @cached
+    get sortedGuests() {
+      return this.guests.slice().sort()
+    }
+  }
+  ```
+
+  Now the `sortedGuests` getter will be cached based on _autotracking_. It will
+  only rerun and create a new sorted array when the `guests` tracked property is
+  updated.
+
+  In general, you should avoid using `@cached` unless you have confirmed that the
+  getter you are decorating is computationally expensive. `@cached` adds a small
+  amount of overhead to the getter, making it more expensive. While this overhead
+  is small, if `@cached` is overused it can add up to a large impact overall in
+  your app. Many getters and tracked properties are only accessed once, rendered,
+  and then never rerendered, so adding `@cached` when it is unnecessary can
+  negatively impact performance.
+
+  @method cached
+  @static
+  @for @glimmer/tracking
+  @public
+ */

package/dist/packages/ember/index.js

@@ -15,8 +15,8 @@ import { _getStrings, _setStrings, dasherize, camelize, capitalize, classify, de
 import Service, { service } from '@ember/service';
 import { action, computed } from '@ember/object';
 import { dependentKeyCompat } from '@ember/object/compat';
-import { Object as EmberObject, RegistryProxyMixin, ContainerProxyMixin, compare, isEqual, Array as EmberArray, MutableEnumerable, MutableArray, TargetActionSupport, Evented, PromiseProxyMixin, Observable, typeOf, isArray, _ProxyMixin, RSVP, Comparable, Namespace, Enumerable, ArrayProxy, ObjectProxy, ActionHandler, CoreObject, NativeArray, A } from '@ember/-internals/runtime';
-import { Checkbox, Component, componentCapabilities, modifierCapabilities, setComponentManager, escapeExpression, getTemplates, Helper, helper, htmlSafe, isHTMLSafe, LinkComponent, setTemplates, template, TextField, TextArea, Input, isSerializationFirstNode } from '@ember/-internals/glimmer'; // eslint-disable-next-line import/no-unresolved
+import { Object as EmberObject, RegistryProxyMixin, ContainerProxyMixin, compare, isEqual, Array as EmberArray, MutableEnumerable, MutableArray, Evented, PromiseProxyMixin, Observable, typeOf, isArray, _ProxyMixin, RSVP, Comparable, Namespace, Enumerable, ArrayProxy, ObjectProxy, ActionHandler, CoreObject, NativeArray, A } from '@ember/-internals/runtime';
+import { Component, componentCapabilities, modifierCapabilities, setComponentManager, escapeExpression, getTemplates, Helper, helper, htmlSafe, isHTMLSafe, setTemplates, template, Input, isSerializationFirstNode } from '@ember/-internals/glimmer'; // eslint-disable-next-line import/no-unresolved
 
 import VERSION from './version';
 import * as views from '@ember/-internals/views';
@@ -164,12 +164,16 @@ Ember._isDestroyed = isDestroyed;
   and reporting code.
 
   ```javascript
-  import $ from 'jquery';
 
   Ember.onerror = function(error) {
-    $.ajax('/report-error', 'POST', {
+    const payload = {
       stack: error.stack,
       otherInformation: 'whatever app state you want to provide'
+    };
+
+    fetch('/report-error', {
+      method: 'POST',
+      body: JSON.stringify(payload)
     });
   };
   ```
@@ -296,52 +300,6 @@ Object.defineProperty(Ember, 'BOOTED', {
 Ember.Component = Component;
 Helper.helper = helper;
 Ember.Helper = Helper;
-
-if (true
-/* EMBER_MODERNIZED_BUILT_IN_COMPONENTS */
-) {
-  [['Checkbox', '@ember/component/checkbox', Checkbox, true], ['TextField', '@ember/component/text-field', TextField, true], ['TextArea', '@ember/component/text-area', TextArea, true], ['LinkComponent', '@ember/routing/link-component', LinkComponent, true], ['TextSupport', null, views.TextSupport, false], ['TargetActionSupport', null, TargetActionSupport, false]].forEach(([name, path, value, availableInLegacyAddon]) => {
-    Object.defineProperty(Ember, name, {
-      get() {
-        let message = `Using Ember.${name}`;
-
-        if (path !== null) {
-          message += ` or importing from '${path}'`;
-        }
-
-        message += ` is deprecated.`;
-
-        if (availableInLegacyAddon) {
-          message += ` Install the \`@ember/legacy-built-in-components\` addon and use ` + `\`import { ${name} } from '@ember/legacy-built-in-components';\` instead.`;
-        }
-
-        deprecate(message, false, {
-          id: 'ember.built-in-components.import',
-          until: '4.0.0',
-          for: 'ember-source',
-          since: {
-            enabled: '3.27.0'
-          },
-          url: 'https://deprecations.emberjs.com/v3.x#toc_ember-built-in-components-import'
-        });
-        return value;
-      },
-
-      configurable: true,
-      enumerable: true
-    }); // Expose a non-deprecated version for tests and the @ember/legacy-built-in-components addon
-
-    Ember[`_Legacy${name}`] = value;
-  });
-} else {
-  Ember.Checkbox = Checkbox;
-  Ember.TextField = TextField;
-  Ember.TextArea = TextArea;
-  Ember.LinkComponent = LinkComponent;
-  Ember.TextSupport = views.TextSupport;
-  Ember.TargetActionSupport = TargetActionSupport;
-}
-
 Ember._setComponentManager = setComponentManager;
 Ember._componentManagerCapabilities = componentCapabilities;
 Ember._setModifierManager = setModifierManager;
@@ -553,14 +511,4 @@ Ember.__loader = {
   // eslint-disable-next-line no-undef
   registry: typeof requirejs !== 'undefined' ? requirejs.entries : require.entries
 };
-export default Ember;
-/**
- @module jquery
- @public
- */
-
-/**
- @class jquery
- @public
- @static
- */
+export default Ember;

package/dist/packages/ember/version.js

@@ -1 +1 @@
-export default "4.1.0-alpha.6";
+export default "4.2.0-alpha.1";