ember-source 7.3.0-alpha.5 → 7.3.0-beta.1

package/types/stable/@ember/-internals/glimmer/lib/helpers/fn.d.ts

@@ -1,77 +0,0 @@
-declare module '@ember/-internals/glimmer/lib/helpers/fn' {
-    /**
-    @module ember
-    */
-    /**
-      The `fn` helper allows you to ensure a function that you are passing off
-      to another component, helper, or modifier has access to arguments that are
-      available in the template.
-
-      For example, if you have an `each` helper looping over a number of items, you
-      may need to pass a function that expects to receive the item as an argument
-      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/components/items-listing.gjs
-      <template>
-        {{#each @items as |item|}}
-          <DisplayItem @item=item @select={{fn this.handleSelected item}} />
-        {{/each}}
-      </template>
-      ```
-
-      ```app/components/items-list.gjs
-      import Component from '@glimmer/component';
-      import { action } from '@ember/object';
-
-      export default class ItemsList extends Component {
-        @action
-        handleSelected(item) {
-          // ...snip...
-        }
-      }
-      ```
-
-      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.
-
-      Let's take look at what that means in a couple circumstances:
-
-      - When invoked as `this.args.select()` the `handleSelected` function will
-        receive the `item` from the loop as its first and only argument.
-      - When invoked as `this.args.select('foo')` the `handleSelected` function
-        will receive the `item` from the loop as its first argument and the
-        string `'foo'` as its second argument.
-
-      In the example above, we used `@action` to ensure that `handleSelected` is
-      properly bound to the `items-list`, but let's explore what happens if we
-      left out `@action`:
-
-      ```app/components/items-list.gjs
-      import Component from '@glimmer/component';
-
-      export default class ItemsList extends Component {
-        handleSelected(item) {
-          // ...snip...
-        }
-      }
-      ```
-
-      In this example, when `handleSelected` is invoked inside the `display-item`
-      component, it will **not** have access to the component instance. In other
-      words, it will have no `this` context, so please make sure your functions
-      are bound (via `@action` or other means) before passing into `fn`!
-
-      See also [partial application](https://en.wikipedia.org/wiki/Partial_application).
-     
-      `fn` is built-in and does not need to be imported.
-
-      @method fn
-      @for @ember/helper
-      @public
-      @since 3.11.0
-    */
-    export {};
-}

package/types/stable/@ember/-internals/glimmer/lib/helpers/get.d.ts

@@ -1,94 +0,0 @@
-declare module '@ember/-internals/glimmer/lib/helpers/get' {
-    /**
-    @module ember
-    */
-    /**
-      Dynamically look up a property on an object or an element in an array.
-      The second argument to `{{get}}` should have a string or number value,
-      although it can be bound.
-
-      For example, these two usages are equivalent:
-
-      ```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>
-      }
-      ```
-        
-      If there were several facts about a person, the `{{get}}` helper can dynamically
-      pick one:
-
-      ```app/templates/application.gjs
-      import DeveloperDetail from '../components/developer-detail';
-      
-      <template>
-        <DeveloperDetail @factName="language" />
-      </template
-      ```
-
-      ```handlebars
-      {{get this.developer @factName}}
-      ```
-
-      For a more complex example, this template would allow the user to switch
-      between showing the user's name and preferred coding language with a click:
-
-      ```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"
-        }
-
-        @tracked currentFact = 'name'
-
-        @action
-        showFact(fact) {
-          this.currentFact = fact;
-        }
-        
-        <template>
-          {{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>
-      }
-      ```
-
-      The `{{get}}` helper can also be used for array element access via index.
-      This would display the value of the first element in the array `this.names`:
-
-      ```handlebars
-      {{get this.names 0}}
-      ```
-
-      Array element access also works with a dynamic second argument:
-
-      ```handlebars
-      {{get this.names @index}}
-      ```
-
-      @public
-      @method get
-      @for @ember/helper
-      @since 2.1.0
-     */
-    export {};
-}

package/types/stable/@ember/-internals/glimmer/lib/helpers/hash.d.ts

@@ -1,46 +0,0 @@
-declare module '@ember/-internals/glimmer/lib/helpers/hash' {
-    /**
-    @module ember
-    */
-    /**
-       Use the `{{hash}}` helper to create a hash to pass as an option to your
-       components. This is especially useful for contextual components where you can
-       just yield a hash:
-
-       ```handlebars
-       {{yield (hash
-          name='Sarah'
-          title=office
-       )}}
-       ```
-
-       Would result in an object such as:
-
-       ```js
-       { name: 'Sarah', title: this.get('office') }
-       ```
-
-       Where the `title` is bound to updates of the `office` property.
-
-       Note that the hash is an empty object with no prototype chain, therefore
-       common methods like `toString` are not available in the resulting hash.
-       If you need to use such a method, you can use the `call` or `apply`
-       approach:
-
-       ```js
-       function toString(obj) {
-         return Object.prototype.toString.apply(obj);
-       }
-       ```
-     
-       The `hash` helper is a built-in keyword and does not need to be imported as of v7.1.0.
-
-       @method hash
-       @for @ember/helper
-       @param {Object} options
-       @return {Object} Hash
-       @since 2.3.0
-       @public
-     */
-    export {};
-}

package/types/stable/@ember/-internals/glimmer/lib/helpers/helper.d.ts

@@ -1,43 +0,0 @@
-declare module '@ember/-internals/glimmer/lib/helpers/helper' {
-    /**
-     @module ember
-     */
-    /**
-     Use the `{{helper}}` helper to create contextual helper so
-     that it can be passed around as first-class values in templates.
-
-     ```handlebars
-     {{#let (helper "join-words" "foo" "bar" separator=" ") as |foo-bar|}}
-
-       {{!-- this is equivalent to invoking `{{join-words "foo" "bar" separator=" "}}` --}}
-       {{foo-bar}}
-
-       {{!-- this will pass the helper itself into the component, instead of invoking it now --}}
-       <MyComponent @helper={{helper foo-bar "baz"}} />
-
-       {{!-- this will yield the helper itself ("contextual helper"), instead of invoking it now --}}
-       {{yield foo-bar}}
-     {{/let}}
-     ```
-
-     ### Arguments
-
-     The `{{helper}}` helper works similarly to the [`{{component}}`](./component?anchor=component) and
-     [`{{modifier}}`](./modifier?anchor=modifier) helper:
-
-     * When passed a string (e.g. `(helper "foo")`) as the first argument,
-       it will produce an opaque, internal "helper definition" object
-       that can be passed around and invoked elsewhere.
-
-     * Any additional positional and/or named arguments (a.k.a. params and hash)
-       will be stored ("curried") inside the definition object, such that, when invoked,
-       these arguments will be passed along to the referenced helper.
-
-
-     @method helper
-     @for Ember.Templates.helpers
-     @public
-     @since 3.27.0
-     */
-    export {};
-}

package/types/stable/@ember/-internals/glimmer/lib/helpers/if-unless.d.ts

@@ -1,228 +0,0 @@
-declare module '@ember/-internals/glimmer/lib/helpers/if-unless' {
-    /**
-    @module ember
-    */
-    /**
-      The `if` helper allows you to conditionally render one of two branches,
-      depending on the "truthiness" of a property.
-      For example the following values are all falsey: `false`, `undefined`, `null`, `""`, `0`, `NaN` or an empty array.
-
-      This helper has two forms, block and inline.
-
-      ## Block form
-
-      You can use the block form of `if` to conditionally render a section of the template.
-
-      To use it, pass the conditional value to the `if` helper,
-      using the block form to wrap the section of template you want to conditionally render.
-      Like so:
-
-      ```app/templates/application.gjs
-      import Weather from '../components/weather';
-        
-      <template>
-        <Weather />
-      </template>
-      ```
-
-      ```app/components/weather.gjs
-      <template>
-        {{! will not render because greeting is undefined}}
-        {{#if @isRaining}}
-          Yes, grab an umbrella!
-        {{/if}}
-      </template>
-      ```
-
-      You can also define what to show if the property is falsey by using
-      the `else` helper.
-
-      ```app/components/weather.gjs
-      <template>
-        {{#if @isRaining}}
-          Yes, grab an umbrella!
-        {{else}}
-          No, it's lovely outside!
-        {{/if}}
-      </template>
-      ```
-
-      You are also able to combine `else` and `if` helpers to create more complex
-      conditional logic.
-
-      For the following template:
-
-       ```app/components/weather.gjs
-      <template>
-        {{#if @isRaining}}
-          Yes, grab an umbrella!
-        {{else if @isCold}}
-          Grab a coat, it's chilly!
-        {{else}}
-          No, it's lovely outside!
-        {{/if}}
-      </template>
-      ```
-
-      If you call it by saying `isCold` is true:
-
-      ```app/templates/application.gjs
-      import Weather from '../components/weather';
-        
-      <template>
-        <Weather @isCold={{true}} />
-      </template>
-      ```
-
-      Then `Grab a coat, it's chilly!` will be rendered.
-
-      ## Inline form
-
-      The inline `if` helper conditionally renders a single property or string.
-
-      In this form, the `if` helper receives three arguments, the conditional value,
-      the value to render when truthy, and the value to render when falsey.
-
-      For example, if `useLongGreeting` is truthy, the following:
-
-      ```app/templates/application.gjs
-      import Greeting from '../components/greeting';
-      
-      <template>
-        <Greeting @useLongGreeting={{true}} />
-      <template>
-      ```
-
-      ```app/components/greeting.gjs
-      <template>
-        {{if @useLongGreeting "Hello" "Hi"}} Alex
-      <template>
-      ```
-
-      Will render:
-
-      ```html
-      Hello Alex
-      ```
-
-      One detail to keep in mind is that both branches of the `if` helper will be evaluated,
-      so if you have `{{if condition "foo" (expensive-operation "bar")`,
-      `expensive-operation` will always calculate.
-     
-      `if` is built-in and does not need to be imported.
-     
-      @method if
-      @for Ember.Templates.helpers
-      @public
-    */
-    /**
-      The `unless` helper is the inverse of the `if` helper. It displays if a value
-      is falsey ("not true" or "is false"). Example values that will display with
-      `unless`: `false`, `undefined`, `null`, `""`, `0`, `NaN` or an empty array.
-
-      ## Inline form
-
-      The inline `unless` helper conditionally renders a single property or string.
-      This helper acts like a ternary operator. If the first property is falsy,
-      the second argument will be displayed, otherwise, the third argument will be
-      displayed
-
-      For example, if you pass a falsey `useLongGreeting` to the `Greeting` component:
-
-      ```app/templates/application.gjs
-      import Greeting from '../components/greeting';
-        
-      <template>
-        <Greeting @useLongGreeting={{false}} />
-      </template>
-      ```
-
-      ```app/components/greeting.gjs
-      <template>
-        {{unless @useLongGreeting "Hi" "Hello"}} Ben
-      </template>
-      ```
-
-      Then it will display:
-
-      ```html
-      Hi Ben
-      ```
-
-      ## Block form
-
-      Like the `if` helper, the `unless` helper also has a block form.
-
-      The following will not render anything:
-
-      ```app/templates/application.gjs
-      import Greeting from '../components/greeting';
-        
-      <template>
-        <Greeting />
-      </template>
-      ```
-
-      ```app/components/greeting.gjs
-      <template>
-        {{#unless @greeting}}
-          No greeting was found. Why not set one?
-        {{/unless}}
-      </template>
-      ```
-
-      You can also use an `else` helper with the `unless` block. The
-      `else` will display if the value is truthy.
-
-      If you have the following component:
-
-      ```app/components/logged-in.gjs
-      <template>
-        {{#unless @userData}}
-          Please login.
-        {{else}}
-          Welcome back!
-        {{/unless}}
-      </template>
-      ```
-
-      Calling it with a truthy `userData`:
-
-      ```app/templates/application.gjs
-      import LoggedIn from '../components/logged-in';
-        
-      <template>
-        <LoggedIn @userData={{hash username="Zoey"}} />
-      </template>
-      ```
-
-      Will render:
-
-      ```html
-      Welcome back!
-      ```
-
-      and calling it with a falsey `userData`:
-
-      ```app/templates/application.gjs
-      import LoggedIn from '../components/logged-in';
-
-      <template>
-        <LoggedIn @userData={{false}} />
-      </template>
-      ```
-
-      Will render:
-
-      ```html
-      Please login.
-      ```
-     
-      `unless` is built-in and does not need to be imported.
-     
-      @method unless
-      @for Ember.Templates.helpers
-      @public
-    */
-    export {};
-}

package/types/stable/@ember/-internals/glimmer/lib/helpers/log.d.ts

@@ -1,19 +0,0 @@
-declare module '@ember/-internals/glimmer/lib/helpers/log' {
-    /**
-    @module ember
-    */
-    /**
-      `log` allows you to output the value of variables in the current rendering
-      context. `log` also accepts primitive types such as strings or numbers.
-
-      ```handlebars
-      {{log "myVariable:" myVariable }}
-      ```
-
-      @method log
-      @for Ember.Templates.helpers
-      @param {Array} params
-      @public
-    */
-    export {};
-}

package/types/stable/@ember/-internals/glimmer/lib/helpers/modifier.d.ts

@@ -1,42 +0,0 @@
-declare module '@ember/-internals/glimmer/lib/helpers/modifier' {
-    /**
-     @module ember
-     */
-    /**
-     Use the `{{modifier}}` helper to create contextual modifier so
-     that it can be passed around as first-class values in templates.
-
-     ```handlebars
-     {{#let (modifier "click-outside" click=this.submit) as |on-click-outside|}}
-
-       {{!-- this is equivalent to `<MyComponent {{click-outside click=this.submit}} />` --}}
-       <MyComponent {{on-click-outside}} />
-
-       {{!-- this will pass the modifier itself into the component, instead of invoking it now --}}
-       <MyComponent @modifier={{modifier on-click-outside "extra" "args"}} />
-
-       {{!-- this will yield the modifier itself ("contextual modifier"), instead of invoking it now --}}
-       {{yield on-click-outside}}
-     {{/let}}
-     ```
-
-     ### Arguments
-
-     The `{{modifier}}` helper works similarly to the [`{{component}}`](./component?anchor=component) and
-     [`{{helper}}`](./helper?anchor=helper) helper:
-
-     * When passed a string (e.g. `(modifier "foo")`) as the first argument,
-       it will produce an opaque, internal "modifier definition" object
-       that can be passed around and invoked elsewhere.
-
-     * Any additional positional and/or named arguments (a.k.a. params and hash)
-       will be stored ("curried") inside the definition object, such that, when invoked,
-       these arguments will be passed along to the referenced modifier.
-
-     @method modifier
-     @for Ember.Templates.helpers
-     @public
-     @since 3.27.0
-     */
-    export {};
-}

package/types/stable/@ember/-internals/glimmer/lib/helpers/page-title.d.ts

@@ -1,24 +0,0 @@
-declare module '@ember/-internals/glimmer/lib/helpers/page-title' {
-    /**
-    @module ember
-    */
-    /**
-      `page-title` allows you to set the title of any page in your application and
-      append additional titles for each route. For complete documentation, see
-      https://github.com/ember-cli/ember-page-title.
-
-      ```gjs
-      import pageTitle from 'ember-page-title/helpers/page-title';
-      
-      <template>
-        {{pageTitle "My Page Title" }}
-      </template>
-      ```
-
-      @method page-title
-      @for Ember.Templates.helpers
-      @param {String} param
-      @public
-    */
-    export {};
-}

package/types/stable/@ember/-internals/glimmer/lib/modifiers/on.d.ts

@@ -1,95 +0,0 @@
-declare module '@ember/-internals/glimmer/lib/modifiers/on' {
-    /**
-    @module ember
-    */
-    /**
-      The `{{on}}` modifier lets you easily add event listeners (it uses
-      [EventTarget.addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener)
-      internally).
-
-      For example, if you'd like to run a function on your component when a `<button>`
-      in the components template is clicked you might do something like:
-
-      ```app/components/like-post.gjs
-      import Component from '@glimmer/component';
-      import { action } from '@ember/object';
-
-      export default class LikePost extends Component {
-        @action
-        saveLike() {
-          // someone likes your post!
-          // better send a request off to your server...
-        }
-        
-        <template>
-          <button {{on 'click' this.saveLike}}>Like this post!</button>
-        </template>
-      }
-      ```
-
-      ### Arguments
-
-      `{{on}}` accepts two positional arguments, and a few named arguments.
-
-      The positional arguments are:
-
-      - `event` -- the name to use when calling `addEventListener`
-      - `callback` -- the function to be passed to `addEventListener`
-
-      The named arguments are:
-
-      - capture -- a `true` value indicates that events of this type will be dispatched
-        to the registered listener before being dispatched to any EventTarget beneath it
-        in the DOM tree.
-      - once -- indicates that the listener should be invoked at most once after being
-        added. If true, the listener would be automatically removed when invoked.
-      - passive -- if `true`, indicates that the function specified by listener will never
-        call preventDefault(). If a passive listener does call preventDefault(), the user
-        agent will do nothing other than generate a console warning. See
-        [Improving scrolling performance with passive listeners](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Improving_scrolling_performance_with_passive_listeners)
-        to learn more.
-
-      The callback function passed to `{{on}}` will receive any arguments that are passed
-      to the event handler. Most commonly this would be the `event` itself.
-
-      If you would like to pass additional arguments to the function you should use
-      the `{{fn}}` helper.
-
-      For example, in our example case above if you'd like to pass in the post that
-      was being liked when the button is clicked you could do something like:
-
-      ```hbs
-      <button {{on 'click' (fn this.saveLike @post)}}>Like this post!</button>
-      ```
-
-      In this case, the `saveLike` function will receive two arguments: the click event
-      and the value of `@post`.
-
-      ### Function Context
-
-      In the example above, we used `@action` to ensure that `likePost` is
-      properly bound to the `LikePost` Component, but let's explore what happens if we
-      left out `@action`:
-
-      ```app/components/like-post.gjs
-      import Component from '@glimmer/component';
-
-      export default class LikePost extends Component {
-        saveLike() {
-          // ...snip...
-        }
-      }
-      ```
-
-      In this example, when the button is clicked `saveLike` will be invoked,
-      it will **not** have access to the component instance. In other
-      words, it will have no `this` context, so please make sure your functions
-      are bound (via `@action` or other means) before passing into `on`!
-
-      @method on
-      @for Ember.Templates.helpers
-      @public
-      @since 3.11.0
-    */
-    export {};
-}