ember-source 7.1.0-beta.1 → 7.1.0

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

@@ -38,8 +38,8 @@ class EmberObject extends CoreObject.extend(Observable) {
   Decorator that turns the target function into an Action which can be accessed
   directly by reference.
 
-  ```js
-  import Component from '@ember/component';
+  ```gjs
+  import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
   import { action } from '@ember/object';
 
@@ -50,24 +50,24 @@ class EmberObject extends CoreObject.extend(Observable) {
     toggleShowing() {
       this.isShowing = !this.isShowing;
     }
+    
+    <template>
+      <button {{on "click" this.toggleShowing}}>Show tooltip</button>
+    
+      {{#if isShowing}}
+        <div class="tooltip">
+          I'm a tooltip!
+        </div>
+      {{/if}}
+    </template>
   }
   ```
-  ```hbs
-  <!-- template.hbs -->
-  <button {{on "click" this.toggleShowing}}>Show tooltip</button>
-
-  {{#if isShowing}}
-    <div class="tooltip">
-      I'm a tooltip!
-    </div>
-  {{/if}}
-  ```
 
   It also binds the function directly to the instance, so it can be used in any
   context and will correctly refer to the class it came from:
 
-  ```js
-  import Component from '@ember/component';
+  ```gjs
+  import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
   import { action } from '@ember/object';
 
@@ -86,6 +86,10 @@ class EmberObject extends CoreObject.extend(Observable) {
     toggleShowing() {
       this.isShowing = !this.isShowing;
     }
+    
+    <template>
+      {{!-- ...--}}
+    </template>
   }
   ```
 
@@ -164,9 +168,10 @@ setClassicDecorator(action);
   });
   ```
 
-  Also available as `Function.prototype.observes` if prototype extensions are
-  enabled.
-
+  While observers are still supported, there are [plans to deprecate them](https://github.com/emberjs/rfcs/pull/1115)
+  See the [in-progress deprecation guide](https://github.com/ember-learn/deprecation-app/pull/1407) 
+  for guidance on how to avoid using observers.
+ 
   @method observer
   @for @ember/object
   @param {String} propertyNames*

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

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

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

@@ -58,10 +58,14 @@ function isQueryParams(value) {
   supplied model to the route as its `model` context of the route. The block for `LinkTo`
   becomes the contents of the rendered element:
 
-  ```handlebars
-  <LinkTo @route='photoGallery'>
-    Great Hamster Photos
-  </LinkTo>
+  ```gjs
+  import { LinkTo } from '@ember/routing';
+    
+  <template>
+    <LinkTo @route='photoGallery'>
+      Great Hamster Photos
+    </LinkTo>
+  </template>
   ```
 
   This will result in:

package/dist/prod/packages/@ember/routing/route.js

@@ -762,7 +762,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
     ```
      Note that for routes with dynamic segments, this hook is not always
     executed. If the route is entered through a transition (e.g. when
-    using the `link-to` Handlebars helper or the `transitionTo` method
+    using the `link-to` helper or the `transitionTo` method
     of routes), and a model context is already provided this hook
     is not called.
      A model context does not include a primitive string or number,

package/dist/prod/packages/@ember/routing/router-service.js

@@ -35,7 +35,7 @@ function cleanURL(url, rootURL) {
    In this example, the Router service is injected into a component to initiate a transition
    to a dedicated route:
 
-   ```app/components/example.js
+   ```app/components/example.gjs
    import Component from '@glimmer/component';
    import { action } from '@ember/object';
    import { service } from '@ember/service';
@@ -82,7 +82,7 @@ class RouterService extends Service.extend(Evented) {
       In the following example we use the Router service to navigate to a route with a
      specific model from a Component in the first action, and in the second we trigger
      a query-params only transition.
-      ```app/components/example.js
+      ```app/components/example.gjs
      import Component from '@glimmer/component';
      import { action } from '@ember/object';
      import { service } from '@ember/service';
@@ -167,10 +167,14 @@ class RouterService extends Service.extend(Evented) {
     URL is returned as a string that can be used for any purpose.
      In this example, the URL for the `author.books` route for a given author
     is copied to the clipboard.
-     ```app/templates/application.hbs
-    <CopyLink @author={{hash id="tomster" name="Tomster"}} />
+     ```app/templates/application.gjs
+    import CopyLink from '../components/copy-link';
+      
+    <template>
+      <CopyLink @author={{hash id="tomster" name="Tomster"}} />
+    </template>
     ```
-     ```app/components/copy-link.js
+     ```app/components/copy-link.gjs
     import Component from '@glimmer/component';
     import { service } from '@ember/service';
     import { action } from '@ember/object';
@@ -189,10 +193,13 @@ class RouterService extends Service.extend(Evented) {
     ```
      Just like with `transitionTo` and `replaceWith`, `urlFor` can also handle
     query parameters.
-     ```app/templates/application.hbs
-    <CopyLink @author={{hash id="tomster" name="Tomster"}} />
+     ```app/templates/application.gjs
+    import CopyLink from '../components/copy-link';
+     <template>
+      <CopyLink @author={{hash id="tomster" name="Tomster"}} />
+    </template>
     ```
-     ```app/components/copy-link.js
+     ```app/components/copy-link.gjs
     import Component from '@glimmer/component';
     import { service } from '@ember/service';
     import { action } from '@ember/object';
@@ -229,7 +236,7 @@ class RouterService extends Service.extend(Evented) {
      See [model](api/ember/release/classes/Route/methods/model?anchor=model) and
      [queryParams](/api/ember/3.7/classes/Route/properties/queryParams?anchor=queryParams) for more information about these arguments.
       In the following example, `isActive` will return `true` if the current route is `/posts`.
-      ```app/components/posts.js
+      ```app/components/posts.gjs
      import Component from '@glimmer/component';
      import { service } from '@ember/service';
       export default class extends Component {
@@ -241,7 +248,7 @@ class RouterService extends Service.extend(Evented) {
      ```
       The next example includes a dynamic segment, and will return `true` if the current route is `/posts/1`,
      assuming the post has an id of 1:
-      ```app/components/posts.js
+      ```app/components/posts.gjs
      import Component from '@glimmer/component';
      import { service } from '@ember/service';
       export default class extends Component {
@@ -315,7 +322,7 @@ class RouterService extends Service.extend(Evented) {
       See [RouteInfo](/ember/release/classes/RouteInfo) for more info.
       In the following example `recognize` is used to verify if a path belongs to our
      application before transitioning to it.
-      ```
+      ```js
      import Component from '@ember/component';
      import { service } from '@ember/service';
       export default class extends Component {
@@ -613,7 +620,7 @@ class RouterService extends Service.extend(Evented) {
     happens (even when that transition only changes parameters
     and doesn't change the active route).
      Usage example:
-    ```app/components/header.js
+    ```app/components/header.gjs
       import Component from '@glimmer/component';
       import { service } from '@ember/service';
       import { notEmpty } from '@ember/object/computed';

package/dist/prod/packages/@ember/template-compiler/lib/compile-options.js

@@ -1,6 +1,6 @@
-import { o as or, d as not, c as lte, l as lt, b as gte, g as gt, n as neq, a as and, e as eq } from '../../../shared-chunks/or-3AxY5TPj.js';
-import { h as hash, f as fn, a as array } from '../../../shared-chunks/hash-mcs3pEFO.js';
-import { e as element } from '../../../shared-chunks/element-DUOVW5Ho.js';
+import { o as or, d as not, c as lte, l as lt, b as gte, g as gt, n as neq, a as and, e as eq } from '../../../shared-chunks/or-Crsa2wci.js';
+import { h as hash, f as fn, a as array } from '../../../shared-chunks/hash-Dkj3I4L4.js';
+import { e as element } from '../../../shared-chunks/element-9DRa_9dO.js';
 import { on } from '../../modifier/on.js';
 import { STRICT_MODE_KEYWORDS, STRICT_MODE_TRANSFORMS, RESOLUTION_MODE_TRANSFORMS } from './plugins/index.js';
 import { ALLOWED_GLOBALS } from './plugins/allowed-globals.js';

package/dist/prod/packages/@glimmer/runtime/index.js

@@ -3,11 +3,11 @@ export { D as DOMChanges, a as DynamicScopeImpl, E as EnvironmentImpl, b as IDOM
 export { T as TEMPLATE_ONLY_COMPONENT_MANAGER, a as TemplateOnlyComponent, b as TemplateOnlyComponentManager, t as templateOnlyComponent } from '../../shared-chunks/template-only-BtLl0uH0.js';
 export { C as CurriedValue, E as EMPTY_ARGS, a as EMPTY_NAMED, b as EMPTY_POSITIONAL, c as createCapturedArgs, d as curry, r as reifyArgs, e as reifyNamed, f as reifyPositional } from '../../shared-chunks/debug-render-tree-CF5O4-WI.js';
 export { n as normalizeProperty } from '../../shared-chunks/props-fiqxqhAH.js';
-export { a as and, e as eq, g as gt, b as gte, l as lt, c as lte, n as neq, d as not, o as or } from '../../shared-chunks/or-3AxY5TPj.js';
-export { a as array, f as fn, h as hash } from '../../shared-chunks/hash-mcs3pEFO.js';
-export { c as concat, g as get } from '../../shared-chunks/get-t0-itmA-.js';
+export { a as and, e as eq, g as gt, b as gte, l as lt, c as lte, n as neq, d as not, o as or } from '../../shared-chunks/or-Crsa2wci.js';
+export { a as array, f as fn, h as hash } from '../../shared-chunks/hash-Dkj3I4L4.js';
+export { c as concat, g as get } from '../../shared-chunks/get-Dt5L0TcU.js';
 export { i as invokeHelper } from '../../shared-chunks/invoke-Cj5zMqHz.js';
-export { o as on } from '../../shared-chunks/on-B5NVufs_.js';
+export { o as on } from '../../shared-chunks/on-CWgOWNSL.js';
 export { destroy, isDestroyed, isDestroying, registerDestructor } from '../destroyable/index.js';
 import '../../shared-chunks/cache-BIlOoPA7.js';
 import '../../shared-chunks/reference-BshxG6wn.js';

package/dist/prod/packages/ember/version.js

@@ -1,4 +1,4 @@
 // this file gets replaced with the real value during the build
-const VERSION = '7.1.0-beta.1';
+const VERSION = '7.1.0';
 
 export { VERSION as default };

package/dist/prod/packages/shared-chunks/{element-DUOVW5Ho.js → element-9DRa_9dO.js}

@@ -82,6 +82,8 @@ function getElementDefinition(tagName) {
   Passing `null`, `undefined`, or non-string values will throw an assertion error.
 
   Changing the tag name will tear down and recreate the element and its contents.
+ 
+  The `element` helper is built-in and does not need to be imported.
 
   @method element
   @for Ember.Templates.helpers

package/dist/prod/packages/shared-chunks/{get-t0-itmA-.js → get-Dt5L0TcU.js}

@@ -1,6 +1,6 @@
 import { a as createComputeRef, U as UNDEFINED_REFERENCE, v as valueForRef } from './reference-BshxG6wn.js';
 import { f as reifyPositional } from './debug-render-tree-CF5O4-WI.js';
-import { i as internalHelper } from './hash-mcs3pEFO.js';
+import { i as internalHelper } from './hash-Dkj3I4L4.js';
 import { setPath, getPath } from '../@glimmer/global-context/index.js';
 import { i as isDict } from './collections-C3Y8z_9v.js';
 
@@ -19,10 +19,15 @@ const normalizeTextValue = value => {
 
   Example:
 
-  ```handlebars
-  {{some-component name=(concat firstName " " lastName)}}
 
-  {{! would pass name="<first name value> <last name value>" to the component}}
+  ```gjs
+  import { concat } from '@ember/helper';
+
+  <template>
+  {{yield (concat firstName " " lastName)}}
+
+  {{! would yield name="<first name value> <last name value>" to the component}}
+  </template>
   ```
 
   or for angle bracket invocation, you actually don't need concat at all.
@@ -46,28 +51,31 @@ const concat = internalHelper(({
 
   For example, these two usages are equivalent:
 
-  ```app/components/developer-detail.js
+  ```app/components/developer-detail.gjs
   import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
+  import { get } from '@ember/object';
 
   export default class extends Component {
     @tracked developer = {
       name: "Sandi Metz",
       language: "Ruby"
     }
+    
+    <template>
+      {{this.developer.name}}
+      {{get this.developer "name"}}
+    </template>
   }
   ```
 
-  ```handlebars
-  {{this.developer.name}}
-  {{get this.developer "name"}}
-  ```
-
   If there were several facts about a person, the `{{get}}` helper can dynamically
   pick one:
 
-  ```app/templates/application.hbs
-  <DeveloperDetail @factName="language" />
+  ```app/templates/application.gjs
+  <template>
+    <DeveloperDetail @factName="language" />
+  </template>
   ```
 
   ```handlebars
@@ -77,10 +85,11 @@ const concat = internalHelper(({
   For a more complex example, this template would allow the user to switch
   between showing the user's height and weight with a click:
 
-  ```app/components/developer-detail.js
+  ```app/components/developer-detail.gjs
   import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
-
+  import { get } from '@ember/object';
+    
   export default class extends Component {
     @tracked developer = {
       name: "Sandi Metz",
@@ -92,28 +101,16 @@ const concat = internalHelper(({
     showFact = (fact) => {
       this.currentFact = fact;
     }
-  }
-  ```
-
-  ```app/components/developer-detail.js
-  {{get this.developer this.currentFact}}
-
-  <button {{on 'click' (fn this.showFact "name")}}>Show name</button>
-  <button {{on 'click' (fn this.showFact "language")}}>Show language</button>
-  ```
+    
+    <template>
+      {{get this.developer this.currentFact}}
 
-  The `{{get}}` helper can also respect mutable values itself. For example:
-
-  ```app/components/developer-detail.js
-  <Input @value={{mut (get this.person this.currentFact)}} />
-
-  <button {{on 'click' (fn this.showFact "name")}}>Show name</button>
-  <button {{on 'click' (fn this.showFact "language")}}>Show language</button>
+      <button {{on 'click' (fn this.showFact "name")}}>Show name</button>
+      <button {{on 'click' (fn this.showFact "language")}}>Show language</button>
+    </template>
+  }
   ```
 
-  Would allow the user to swap what fact is being displayed, and also edit
-  that fact via a two-way mutable binding.
-
   @public
   @method get
  */

package/dist/prod/packages/shared-chunks/{hash-mcs3pEFO.js → hash-Dkj3I4L4.js}

@@ -19,7 +19,7 @@ function internalHelper(helper) {
    ```
     or
    ```handlebars
-   {{my-component people=(array
+   {{yield people=(array
      'Tom Dale'
      'Yehuda Katz'
      this.myOtherPerson)
@@ -64,13 +64,17 @@ const context = buildUntouchableThis();
   to a component invoked within the loop. Here's how you could use the `fn`
   helper to pass both the function and its arguments together:
 
-    ```app/templates/components/items-listing.hbs
-  {{#each @items as |item|}}
-    <DisplayItem @item=item @select={{fn this.handleSelected item}} />
-  {{/each}}
+  ```app/components/items-listing.gjs
+  import DisplayItem from './display-item';
+    
+  <template>
+    {{#each @items as |item|}}
+      <DisplayItem @item=item @select={{fn this.handleSelected item}} />
+    {{/each}}
+  </template>
   ```
 
-  ```app/components/items-list.js
+  ```app/components/items-list.gjs
   import Component from '@glimmer/component';
   import { action } from '@ember/object';
 
@@ -81,7 +85,7 @@ const context = buildUntouchableThis();
   }
   ```
 
-  In this case the `display-item` component will receive a normal function
+  In this case the `DisplayItem` component will receive a normal function
   that it can invoke. When it invokes the function, the `handleSelected`
   function will receive the `item` and any arguments passed, thanks to the
   `fn` helper.
@@ -98,7 +102,7 @@ const context = buildUntouchableThis();
   `handleSelected` is properly bound to the `items-list`, but let's explore what
   happens if we left out the arrow function:
 
-  ```app/components/items-list.js
+  ```app/components/items-list.gjs
   import Component from '@glimmer/component';
 
   export default class ItemsList extends Component {
@@ -115,6 +119,8 @@ const context = buildUntouchableThis();
 
   See also [partial application](https://en.wikipedia.org/wiki/Partial_application).
 
+  `fn` is built-in and does not require any additional imports.
+ 
   @method fn
   @public
 */
@@ -138,7 +144,7 @@ const fn = internalHelper(({
 
 /**
    Use the `{{hash}}` helper to create a hash to pass as an option to your
-   components. This is specially useful for contextual components where you can
+   components. This is especially useful for contextual components where you can
    just yield a hash:
 
    ```handlebars

package/dist/prod/packages/shared-chunks/{helper-DLjV2ZZW.js → helper-CN6UzshW.js}

@@ -27,20 +27,32 @@ const IS_CLASSIC_HELPER = Symbol('IS_CLASSIC_HELPER');
   Ember Helpers are functions that can compute values, and are used in templates.
   For example, this code calls a helper named `format-currency`:
 
-  ```app/templates/application.hbs
-  <Cost @cents={{230}} />
+  ```app/templates/application.gjs
+  import Cost from '../components/cost';
+    
+  <template>
+    <Cost @cents={{230}} />
+  </template>
   ```
 
-  ```app/components/cost.hbs
-  <div>{{format-currency @cents currency="$"}}</div>
+  ```app/components/cost.gjs
+  import formatCurrency from '../helpers/format-currency';
+    
+  <template>
+    <div>{{formatCurrency @cents currency="$"}}</div>
+  </template>
   ```
 
   Additionally a helper can be called as a nested helper.
   In this example, we show the formatted currency value if the `showMoney`
   named argument is truthy.
 
-  ```handlebars
-  {{if @showMoney (format-currency @cents currency="$")}}
+  ```gjs
+  import formatCurrency from '../helpers/format-currency';
+
+  <template>
+    {{if @showMoney (formatCurrency @cents currency="$")}}
+  </template>
   ```
 
   Helpers defined using a class must provide a `compute` function. For example: