ember-source 4.1.0-alpha.4 → 4.1.0-alpha.8

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

@@ -12,11 +12,11 @@ import Backburner from 'backburner';
 import Controller, { inject as injectController } from '@ember/controller';
 import ControllerMixin from '@ember/controller/lib/controller_mixin';
 import { _getStrings, _setStrings, dasherize, camelize, capitalize, classify, decamelize, loc, underscore, w } from '@ember/string';
-import Service, { inject as injectService } from '@ember/service';
+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)
     });
   };
   ```
@@ -227,7 +231,7 @@ Ember.inject = function inject() {
   assert(`Injected properties must be created through helpers, see '${Object.keys(inject).map(k => `'inject.${k}'`).join(' or ')}'`);
 };
 
-Ember.inject.service = injectService;
+Ember.inject.service = service;
 Ember.inject.controller = injectController;
 Ember.Array = EmberArray;
 Ember.Comparable = Comparable;
@@ -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.4";
+export default "4.1.0-alpha.8";