discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-glimmer/lib/helpers/component.js

@@ -1,135 +0,0 @@
-"use strict";
-/**
-  @module ember
-*/
-/**
-  The `{{component}}` helper lets you add instances of `Component` to a
-  template. See [Component](/api/ember/release/classes/Component) for
-  additional information on how a `Component` functions.
-  `{{component}}`'s primary use is for cases where you want to dynamically
-  change which type of component is rendered as the state of your application
-  changes. This helper has three modes: inline, block, and nested.
-
-  ### Inline Form
-
-  Given the following template:
-
-  ```app/application.hbs
-  {{component infographicComponentName}}
-  ```
-
-  And the following application code:
-
-  ```app/controllers/application.js
-  import Controller from '@ember/controller';
-  import { computed } from '@ember/object';
-
-  export default Controller.extend({
-    infographicComponentName: computed('isMarketOpen', {
-      get() {
-        if (this.get('isMarketOpen')) {
-          return 'live-updating-chart';
-        } else {
-          return 'market-close-summary';
-        }
-      }
-    })
-  });
-  ```
-
-  The `live-updating-chart` component will be appended when `isMarketOpen` is
-  `true`, and the `market-close-summary` component will be appended when
-  `isMarketOpen` is `false`. If the value changes while the app is running,
-  the component will be automatically swapped out accordingly.
-  Note: You should not use this helper when you are consistently rendering the same
-  component. In that case, use standard component syntax, for example:
-
-  ```app/templates/application.hbs
-  {{live-updating-chart}}
-  ```
-
-  ### Block Form
-
-  Using the block form of this helper is similar to using the block form
-  of a component. Given the following application template:
-
-  ```app/templates/application.hbs
-  {{#component infographicComponentName}}
-    Last update: {{lastUpdateTimestamp}}
-  {{/component}}
-  ```
-
-  The following controller code:
-
-  ```app/controllers/application.js
-  import Controller from '@ember/controller';
-  import { computed } from '@ember/object';
-
-  export default Controller.extend({
-    lastUpdateTimestamp: computed(function() {
-      return new Date();
-    }),
-
-    infographicComponentName: computed('isMarketOpen', {
-      get() {
-        if (this.get('isMarketOpen')) {
-          return 'live-updating-chart';
-        } else {
-          return 'market-close-summary';
-        }
-      }
-    })
-  });
-  ```
-
-  And the following component template:
-
-  ```app/templates/components/live-updating-chart.hbs
-  {{! chart }}
-  {{yield}}
-  ```
-
-  The `Last Update: {{lastUpdateTimestamp}}` will be rendered in place of the `{{yield}}`.
-
-  ### Nested Usage
-
-  The `component` helper can be used to package a component path with initial attrs.
-  The included attrs can then be merged during the final invocation.
-  For example, given a `person-form` component with the following template:
-
-  ```app/templates/components/person-form.hbs
-  {{yield (hash
-    nameInput=(component "my-input-component" value=model.name placeholder="First Name")
-  )}}
-  ```
-
-  When yielding the component via the `hash` helper, the component is invoked directly.
-  See the following snippet:
-
-  ```
-  {{#person-form as |form|}}
-    {{form.nameInput placeholder="Username"}}
-  {{/person-form}}
-  ```
-
-  Which outputs an input whose value is already bound to `model.name` and `placeholder`
-  is "Username".
-
-  When yielding the component without the hash helper use the `component` helper.
-  For example, below is a `full-name` component template:
-
-  ```handlebars
-  {{yield (component "my-input-component" value=model.name placeholder="Name")}}
-  ```
-
-  ```
-  {{#full-name as |field|}}
-    {{component field placeholder="Full name"}}
-  {{/full-name}}
-  ```
-
-  @method component
-  @since 1.11.0
-  @for Ember.Templates.helpers
-  @public
-*/

data/dist/es/ember-glimmer/lib/helpers/concat.js

@@ -1,38 +0,0 @@
-import { InternalHelperReference } from '../utils/references';
-const isEmpty = (value) => {
-    return value === null || value === undefined || typeof value.toString !== 'function';
-};
-const normalizeTextValue = (value) => {
-    if (isEmpty(value)) {
-        return '';
-    }
-    return String(value);
-};
-/**
-@module ember
-*/
-/**
-  Concatenates the given arguments into a string.
-
-  Example:
-
-  ```handlebars
-  {{some-component name=(concat firstName " " lastName)}}
-
-  {{! would pass name="<first name value> <last name value>" to the component}}
-  ```
-
-  @public
-  @method concat
-  @for Ember.Templates.helpers
-  @since 1.13.0
-*/
-function concat({ positional }) {
-    return positional
-        .value()
-        .map(normalizeTextValue)
-        .join('');
-}
-export default function (_vm, args) {
-    return new InternalHelperReference(concat, args.capture());
-}

data/dist/es/ember-glimmer/lib/helpers/each-in.js

@@ -1,126 +0,0 @@
-import { symbol } from 'ember-utils';
-/**
-  The `{{#each}}` helper loops over elements in a collection. It is an extension
-  of the base Handlebars `{{#each}}` helper.
-  The default behavior of `{{#each}}` is to yield its inner block once for every
-  item in an array passing the item as the first block parameter.
-
-  ```javascript
-  var developers = [{ name: 'Yehuda' },{ name: 'Tom' }, { name: 'Paul' }];
-  ```
-
-  ```handlebars
-  {{#each developers key="name" as |person|}}
-    {{person.name}}
-    {{! `this` is whatever it was outside the #each }}
-  {{/each}}
-  ```
-
-  The same rules apply to arrays of primitives.
-
-  ```javascript
-  var developerNames = ['Yehuda', 'Tom', 'Paul']
-  ```
-
-  ```handlebars
-  {{#each developerNames key="@index" as |name|}}
-    {{name}}
-  {{/each}}
-  ```
-
-  During iteration, the index of each item in the array is provided as a second block parameter.
-
-  ```handlebars
-  <ul>
-    {{#each people as |person index|}}
-      <li>Hello, {{person.name}}! You're number {{index}} in line</li>
-    {{/each}}
-  </ul>
-  ```
-
-  ### Specifying Keys
-
-  The `key` option is used to tell Ember how to determine if the array being
-  iterated over with `{{#each}}` has changed between renders. By helping Ember
-  detect that some elements in the array are the same, DOM elements can be
-  re-used, significantly improving rendering speed.
-
-  For example, here's the `{{#each}}` helper with its `key` set to `id`:
-
-  ```handlebars
-  {{#each model key="id" as |item|}}
-  {{/each}}
-  ```
-
-  When this `{{#each}}` re-renders, Ember will match up the previously rendered
-  items (and reorder the generated DOM elements) based on each item's `id`
-  property.
-  By default the item's own reference is used.
-
-  ### {{else}} condition
-
-  `{{#each}}` can have a matching `{{else}}`. The contents of this block will render
-  if the collection is empty.
-
-  ```handlebars
-  {{#each developers as |person|}}
-    {{person.name}}
-  {{else}}
-    <p>Sorry, nobody is available for this task.</p>
-  {{/each}}
-  ```
-
-  @method each
-  @for Ember.Templates.helpers
-  @public
- */
-/**
-  The `{{each-in}}` helper loops over properties on an object.
-
-  For example, given a `user` object that looks like:
-
-  ```javascript
-  {
-    "name": "Shelly Sails",
-    "age": 42
-  }
-  ```
-
-  This template would display all properties on the `user`
-  object in a list:
-
-  ```handlebars
-  <ul>
-  {{#each-in user as |key value|}}
-    <li>{{key}}: {{value}}</li>
-  {{/each-in}}
-  </ul>
-  ```
-
-  Outputting their name and age.
-
-  @method each-in
-  @for Ember.Templates.helpers
-  @public
-  @since 2.1.0
-*/
-const EACH_IN_REFERENCE = symbol('EACH_IN');
-class EachInReference {
-    constructor(inner) {
-        this.inner = inner;
-        this.tag = inner.tag;
-        this[EACH_IN_REFERENCE] = true;
-    }
-    value() {
-        return this.inner.value();
-    }
-    get(key) {
-        return this.inner.get(key);
-    }
-}
-export function isEachIn(ref) {
-    return ref !== null && typeof ref === 'object' && ref[EACH_IN_REFERENCE];
-}
-export default function (_vm, args) {
-    return new EachInReference(args.positional.at(0));
-}

data/dist/es/ember-glimmer/lib/helpers/get.js

@@ -1,100 +0,0 @@
-import { combine, CONSTANT_TAG, isConst, UpdatableTag, } from '@glimmer/reference';
-import { NULL_REFERENCE } from '@glimmer/runtime';
-import { set } from 'ember-metal';
-import { CachedReference, referenceFromParts, UPDATE } from '../utils/references';
-/**
-@module ember
-*/
-/**
-  Dynamically look up a property on an object. The second argument to `{{get}}`
-  should have a string value, although it can be bound.
-
-  For example, these two usages are equivalent:
-
-  ```handlebars
-  {{person.height}}
-  {{get person "height"}}
-  ```
-
-  If there were several facts about a person, the `{{get}}` helper can dynamically
-  pick one:
-
-  ```handlebars
-  {{get person factName}}
-  ```
-
-  For a more complex example, this template would allow the user to switch
-  between showing the user's height and weight with a click:
-
-  ```handlebars
-  {{get person factName}}
-  <button {{action (action (mut factName)) "height"}}>Show height</button>
-  <button {{action (action (mut factName)) "weight"}}>Show weight</button>
-  ```
-
-  The `{{get}}` helper can also respect mutable values itself. For example:
-
-  ```handlebars
-  {{input value=(mut (get person factName)) type="text"}}
-  <button {{action (action (mut factName)) "height"}}>Show height</button>
-  <button {{action (action (mut factName)) "weight"}}>Show weight</button>
-  ```
-
-  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
-  @for Ember.Templates.helpers
-  @since 2.1.0
- */
-export default function (_vm, args) {
-    return GetHelperReference.create(args.positional.at(0), args.positional.at(1));
-}
-function referenceFromPath(source, path) {
-    let innerReference;
-    if (path === undefined || path === null || path === '') {
-        innerReference = NULL_REFERENCE;
-    }
-    else if (typeof path === 'string' && path.indexOf('.') > -1) {
-        innerReference = referenceFromParts(source, path.split('.'));
-    }
-    else {
-        innerReference = source.get(path);
-    }
-    return innerReference;
-}
-class GetHelperReference extends CachedReference {
-    static create(sourceReference, pathReference) {
-        if (isConst(pathReference)) {
-            let path = pathReference.value();
-            return referenceFromPath(sourceReference, path);
-        }
-        else {
-            return new GetHelperReference(sourceReference, pathReference);
-        }
-    }
-    constructor(sourceReference, pathReference) {
-        super();
-        this.sourceReference = sourceReference;
-        this.pathReference = pathReference;
-        this.lastPath = null;
-        this.innerReference = NULL_REFERENCE;
-        let innerTag = (this.innerTag = UpdatableTag.create(CONSTANT_TAG));
-        this.tag = combine([sourceReference.tag, pathReference.tag, innerTag]);
-    }
-    compute() {
-        let { lastPath, innerReference, innerTag } = this;
-        let path = this.pathReference.value();
-        if (path !== lastPath) {
-            innerReference = referenceFromPath(this.sourceReference, path);
-            innerTag.inner.update(innerReference.tag);
-            this.innerReference = innerReference;
-            this.lastPath = path;
-        }
-        return innerReference.value();
-    }
-    [UPDATE](value) {
-        set(this.sourceReference.value(), this.pathReference.value(), value);
-    }
-}

data/dist/es/ember-glimmer/lib/helpers/hash.js

@@ -1,44 +0,0 @@
-/**
-@module ember
-*/
-/**
-   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
-   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);
-   }
-   ```
-
-   @method hash
-   @for Ember.Templates.helpers
-   @param {Object} options
-   @return {Object} Hash
-   @since 2.3.0
-   @public
- */
-export default function (_vm, args) {
-    return args.named.capture();
-}