ember-source 7.1.0-alpha.4 → 7.1.0-beta.1

package/dist/prod/packages/shared-chunks/get-t0-itmA-.js

@@ -0,0 +1,138 @@
+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 { setPath, getPath } from '../@glimmer/global-context/index.js';
+import { i as isDict } from './collections-C3Y8z_9v.js';
+
+const isEmpty = value => {
+  return value === null || value === undefined || typeof value.toString !== 'function';
+};
+const normalizeTextValue = value => {
+  if (isEmpty(value)) {
+    return '';
+  }
+  return String(value);
+};
+
+/**
+  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}}
+  ```
+
+  or for angle bracket invocation, you actually don't need concat at all.
+
+  ```handlebars
+  <SomeComponent @name="{{firstName}} {{lastName}}" />
+  ```
+
+  @public
+  @method concat
+*/
+const concat = internalHelper(({
+  positional
+}) => {
+  return createComputeRef(() => reifyPositional(positional).map(normalizeTextValue).join(''), null, 'concat');
+});
+
+/**
+  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:
+
+  ```app/components/developer-detail.js
+  import Component from '@glimmer/component';
+  import { tracked } from '@glimmer/tracking';
+
+  export default class extends Component {
+    @tracked developer = {
+      name: "Sandi Metz",
+      language: "Ruby"
+    }
+  }
+  ```
+
+  ```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" />
+  ```
+
+  ```handlebars
+  {{get this.developer @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:
+
+  ```app/components/developer-detail.js
+  import Component from '@glimmer/component';
+  import { tracked } from '@glimmer/tracking';
+
+  export default class extends Component {
+    @tracked developer = {
+      name: "Sandi Metz",
+      language: "Ruby"
+    }
+
+    @tracked currentFact = 'name'
+
+    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>
+  ```
+
+  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>
+  ```
+
+  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
+ */
+const get = internalHelper(({
+  positional
+}) => {
+  let sourceRef = positional[0] ?? UNDEFINED_REFERENCE;
+  let pathRef = positional[1] ?? UNDEFINED_REFERENCE;
+  return createComputeRef(() => {
+    let source = valueForRef(sourceRef);
+    if (isDict(source)) {
+      return getPath(source, String(valueForRef(pathRef)));
+    }
+  }, value => {
+    let source = valueForRef(sourceRef);
+    if (isDict(source)) {
+      return setPath(source, String(valueForRef(pathRef)), value);
+    }
+  }, 'get');
+});
+
+export { concat as c, get as g };

package/dist/prod/packages/shared-chunks/get_properties-Nn08mLAH.js

@@ -0,0 +1,55 @@
+import { g as get } from './property_get-CAFdpRyu.js';
+
+/**
+ @module @ember/object
+*/
+
+/**
+  To get multiple properties at once, call `getProperties`
+  with an object followed by a list of strings or an array:
+
+  ```javascript
+  import { getProperties } from '@ember/object';
+
+  getProperties(record, 'firstName', 'lastName', 'zipCode');
+  // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
+  ```
+
+  is equivalent to:
+
+  ```javascript
+  import { getProperties } from '@ember/object';
+
+  getProperties(record, ['firstName', 'lastName', 'zipCode']);
+  // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
+  ```
+
+  @method getProperties
+  @static
+  @for @ember/object
+  @param {Object} obj
+  @param {String...|Array} list of keys to get
+  @return {Object}
+  @public
+*/
+
+function getProperties(obj, keys) {
+  let ret = {};
+  let propertyNames;
+  let i = 1;
+  if (arguments.length === 2 && Array.isArray(keys)) {
+    i = 0;
+    propertyNames = arguments[1];
+  } else {
+    propertyNames = Array.from(arguments);
+  }
+  for (; i < propertyNames.length; i++) {
+    // SAFETY: we are just walking the list of property names, so we know the
+    // index access never produces `undefined`.
+    let name = propertyNames[i];
+    ret[name] = get(obj, name);
+  }
+  return ret;
+}
+
+export { getProperties as g };

package/dist/prod/packages/shared-chunks/guid-Cbq2sNV_.js

@@ -0,0 +1,123 @@
+import { i as intern } from './intern-zquhAEIg.js';
+import { i as isObject } from './spec-BXl1reqK.js';
+
+/**
+ @module @ember/object
+*/
+
+/**
+ @private
+ @return {Number} the uuid
+ */
+let _uuid = 0;
+
+/**
+ Generates a universally unique identifier. This method
+ is used internally by Ember for assisting with
+ the generation of GUID's and other unique identifiers.
+
+ @public
+ @return {Number} [description]
+ */
+function uuid() {
+  return ++_uuid;
+}
+
+/**
+ Prefix used for guids through out Ember.
+ @private
+ @property GUID_PREFIX
+ @for Ember
+ @type String
+ @final
+ */
+const GUID_PREFIX = 'ember';
+
+// Used for guid generation...
+const OBJECT_GUIDS = new WeakMap();
+const NON_OBJECT_GUIDS = new Map();
+/**
+  A unique key used to assign guids and other private metadata to objects.
+  If you inspect an object in your browser debugger you will often see these.
+  They can be safely ignored.
+
+  On browsers that support it, these properties are added with enumeration
+  disabled so they won't show up when you iterate over your properties.
+
+  @private
+  @property GUID_KEY
+  @for Ember
+  @type String
+  @final
+*/
+const GUID_KEY = intern(`__ember${Date.now()}`);
+
+/**
+  Generates a new guid, optionally saving the guid to the object that you
+  pass in. You will rarely need to use this method. Instead you should
+  call `guidFor(obj)`, which return an existing guid if available.
+
+  @private
+  @method generateGuid
+  @static
+  @for @ember/object/internals
+  @param {Object} [obj] Object the guid will be used for. If passed in, the guid will
+    be saved on the object and reused whenever you pass the same object
+    again.
+
+    If no object is passed, just generate a new guid.
+  @param {String} [prefix] Prefix to place in front of the guid. Useful when you want to
+    separate the guid into separate namespaces.
+  @return {String} the guid
+*/
+// eslint-disable-next-line @typescript-eslint/no-wrapper-object-types
+function generateGuid(obj, prefix = GUID_PREFIX) {
+  let guid = prefix + uuid().toString();
+  if (isObject(obj)) {
+    OBJECT_GUIDS.set(obj, guid);
+  }
+  return guid;
+}
+
+/**
+  Returns a unique id for the object. If the object does not yet have a guid,
+  one will be assigned to it. You can call this on any object,
+  `EmberObject`-based or not.
+
+  You can also use this method on DOM Element objects.
+
+  @public
+  @static
+  @method guidFor
+  @for @ember/object/internals
+  @param {Object} obj any object, string, number, Element, or primitive
+  @return {String} the unique guid for this instance.
+*/
+function guidFor(value) {
+  let guid;
+  if (isObject(value)) {
+    guid = OBJECT_GUIDS.get(value);
+    if (guid === undefined) {
+      guid = `${GUID_PREFIX}${uuid()}`;
+      OBJECT_GUIDS.set(value, guid);
+    }
+  } else {
+    guid = NON_OBJECT_GUIDS.get(value);
+    if (guid === undefined) {
+      let type = typeof value;
+      if (type === 'string') {
+        guid = `st${uuid()}`;
+      } else if (type === 'number') {
+        guid = `nu${uuid()}`;
+      } else if (type === 'symbol') {
+        guid = `sy${uuid()}`;
+      } else {
+        guid = `(${value})`;
+      }
+      NON_OBJECT_GUIDS.set(value, guid);
+    }
+  }
+  return guid;
+}
+
+export { GUID_KEY as G, generateGuid as a, guidFor as g, uuid as u };

package/dist/prod/packages/shared-chunks/hash-mcs3pEFO.js

@@ -0,0 +1,192 @@
+import { a as createComputeRef, i as isInvokableRef, u as updateRef } from './reference-BshxG6wn.js';
+import { f as reifyPositional, g as check, e as reifyNamed } from './debug-render-tree-CF5O4-WI.js';
+import { j as setInternalHelperManager } from './api-zh_k31vb.js';
+
+function internalHelper(helper) {
+  return setInternalHelperManager(helper, {});
+}
+
+/**
+   Use the `{{array}}` helper to create an array to pass as an option to your
+   components.
+
+   ```handlebars
+   <MyComponent @people={{array
+     'Tom Dale'
+     'Yehuda Katz'
+     this.myOtherPerson}}
+   />
+   ```
+    or
+   ```handlebars
+   {{my-component people=(array
+     'Tom Dale'
+     'Yehuda Katz'
+     this.myOtherPerson)
+   }}
+   ```
+
+   Would result in an object such as:
+
+   ```js
+   ['Tom Dale', 'Yehuda Katz', this.get('myOtherPerson')]
+   ```
+
+   Where the 3rd item in the array is bound to updates of the `myOtherPerson` property.
+
+   @method array
+   @param {Array} options
+   @return {Array} Array
+   @public
+ */
+
+const array = internalHelper(({
+  positional
+}) => {
+  return createComputeRef(() => reifyPositional(positional), null, 'array');
+});
+
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+function buildUntouchableThis(source) {
+  let context = null;
+  return context;
+}
+
+const context = buildUntouchableThis();
+
+/**
+  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/templates/components/items-listing.hbs
+  {{#each @items as |item|}}
+    <DisplayItem @item=item @select={{fn this.handleSelected item}} />
+  {{/each}}
+  ```
+
+  ```app/components/items-list.js
+  import Component from '@glimmer/component';
+  import { action } from '@ember/object';
+
+  export default class ItemsList extends Component {
+    handleSelected = (item) => {
+      // ...snip...
+    }
+  }
+  ```
+
+  In this case the `display-item` 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 an arrow function to ensure that
+  `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
+  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 an arrow function or other means) before passing into `fn`!
+
+  See also [partial application](https://en.wikipedia.org/wiki/Partial_application).
+
+  @method fn
+  @public
+*/
+const fn = internalHelper(({
+  positional
+}) => {
+  let callbackRef = check(positional[0]);
+  return createComputeRef(() => {
+    return (...invocationArgs) => {
+      let [fn, ...args] = reifyPositional(positional);
+      if (isInvokableRef(callbackRef)) {
+        let value = args.length > 0 ? args[0] : invocationArgs[0];
+        return void updateRef(callbackRef, value);
+      } else {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- @fixme
+        return fn.call(context, ...args, ...invocationArgs);
+      }
+    };
+  }, null, 'fn');
+});
+
+/**
+   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
+   @param {Object} options
+   @return {Object} Hash
+   @public
+ */
+const hash = internalHelper(({
+  named
+}) => {
+  let ref = createComputeRef(() => {
+    return reifyNamed(named);
+  }, null, 'hash');
+
+  // Setup the children so that templates can bypass getting the value of
+  // the reference and treat children lazily
+  let children = new Map();
+  for (let name in named) {
+    children.set(name, named[name]);
+  }
+  ref.children = children;
+  return ref;
+});
+
+export { array as a, fn as f, hash as h, internalHelper as i };