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

package/dist/dev/packages/shared-chunks/textarea-WSlUEr0y.js

@@ -0,0 +1,468 @@
+import { h as hasDOM } from './index-BGP1rw3B.js';
+import { warn } from '../@ember/debug/index.js';
+import { action } from '../@ember/object/index.js';
+import { i as isConstRef, v as valueForRef, d as isUpdatableRef, u as updateRef } from './reference-BoPB2LfI.js';
+import { x as untrack } from './cache-B7dqAS38.js';
+import { on } from '../@ember/modifier/on.js';
+import { t as templateFactory } from './index-CyZiGiEI.js';
+import { I as InternalComponent, o as opaquify } from './internal-CAL-jHZt.js';
+import { d as decorateFieldV2, i as initializeDeferredDecorator, a as decorateMethodV2 } from './runtime-CYyqkz5q-BOdRhmsS.js';
+import { assert } from '../@ember/debug/lib/assert.js';
+import { t as tracked } from './tracked-CKE4wnE6.js';
+
+const InputTemplate = templateFactory(
+/*
+  <input
+  {{!-- for compatibility --}}
+  id={{this.id}}
+  class={{this.class}}
+
+  ...attributes
+
+  type={{this.type}}
+  checked={{this.checked}}
+  value={{this.value}}
+
+  {{on "change" this.change}}
+  {{on "input" this.input}}
+  {{on "keyup" this.keyUp}}
+  {{on "paste" this.valueDidChange}}
+  {{on "cut" this.valueDidChange}}
+/>
+*/
+{
+  "id": null,
+  "block": "[[[11,\"input\"],[16,1,[30,0,[\"id\"]]],[16,0,[30,0,[\"class\"]]],[17,1],[16,4,[30,0,[\"type\"]]],[16,\"checked\",[30,0,[\"checked\"]]],[16,2,[30,0,[\"value\"]]],[4,[32,0],[\"change\",[30,0,[\"change\"]]],null],[4,[32,0],[\"input\",[30,0,[\"input\"]]],null],[4,[32,0],[\"keyup\",[30,0,[\"keyUp\"]]],null],[4,[32,0],[\"paste\",[30,0,[\"valueDidChange\"]]],null],[4,[32,0],[\"cut\",[30,0,[\"valueDidChange\"]]],null],[12],[13]],[\"&attrs\"],[]]",
+  "moduleName": "packages/@ember/-internals/glimmer/lib/templates/input.hbs",
+  "scope": () => ({
+    on
+  }),
+  "isStrictMode": true
+});
+
+const UNINITIALIZED = Object.freeze({});
+function elementForEvent(event) {
+  (!(event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement) && assert('[BUG] event target must be an <input> or <textarea> element', event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement));
+  return event.target;
+}
+function valueForEvent(event) {
+  return elementForEvent(event).value;
+}
+function devirtualize(callback) {
+  return event => callback(valueForEvent(event), event);
+}
+function valueFrom(reference) {
+  if (reference === undefined) {
+    return new LocalValue(undefined);
+  } else if (isConstRef(reference)) {
+    return new LocalValue(valueForRef(reference));
+  } else if (isUpdatableRef(reference)) {
+    return new UpstreamValue(reference);
+  } else {
+    return new ForkedValue(reference);
+  }
+}
+class LocalValue {
+  static {
+    decorateFieldV2(this.prototype, "value", [tracked]);
+  }
+  #value = (initializeDeferredDecorator(this, "value"), void 0);
+  constructor(value) {
+    this.value = value;
+  }
+  get() {
+    return this.value;
+  }
+  set(value) {
+    this.value = value;
+  }
+}
+class UpstreamValue {
+  constructor(reference) {
+    this.reference = reference;
+  }
+  get() {
+    return valueForRef(this.reference);
+  }
+  set(value) {
+    updateRef(this.reference, value);
+  }
+}
+class ForkedValue {
+  local;
+  upstream;
+  lastUpstreamValue = UNINITIALIZED;
+  constructor(reference) {
+    this.upstream = new UpstreamValue(reference);
+  }
+  get() {
+    let upstreamValue = this.upstream.get();
+    if (upstreamValue !== this.lastUpstreamValue) {
+      this.lastUpstreamValue = upstreamValue;
+      this.local = new LocalValue(upstreamValue);
+    }
+    (!(this.local) && assert('[BUG] this.local must have been initialized at this point', this.local));
+    return this.local.get();
+  }
+  set(value) {
+    (!(this.local) && assert('[BUG] this.local must have been initialized at this point', this.local));
+    this.local.set(value);
+  }
+}
+class AbstractInput extends InternalComponent {
+  validateArguments() {
+    (!(this.args.positional.length === 0) && assert(`The ${this.constructor} component does not take any positional arguments`, this.args.positional.length === 0));
+    super.validateArguments();
+  }
+  _value = valueFrom(this.args.named['value']);
+  get value() {
+    return this._value.get();
+  }
+  set value(value) {
+    this._value.set(value);
+  }
+  valueDidChange(event) {
+    this.value = valueForEvent(event);
+  }
+
+  /**
+   * The `change` and `input` actions need to be overridden in the `Input`
+   * subclass. Unfortunately, some ember-source builds currently uses babel
+   * loose mode to transpile its classes. Having the `@action` decorator on the
+   * super class creates a getter on the prototype, and when the subclass
+   * overrides the method, the loose mode transpilation would emit something
+   * like `Subclass.prototype['change'] = function change() { ... }`, which
+   * fails because `prototype['change']` is getter-only/readonly. The correct
+   * solution is to use `Object.defineProperty(prototype, 'change', ...)` but
+   * that requires disabling loose mode. For now, the workaround is to add the
+   * decorator only on the subclass. This is more of a configuration issue on
+   * our own builds and doesn't really affect apps.
+   */
+
+  /* @action */
+  static {
+    decorateMethodV2(this.prototype, "valueDidChange", [action]);
+  }
+  change(event) {
+    this.valueDidChange(event);
+  }
+
+  /* @action */
+  input(event) {
+    this.valueDidChange(event);
+  }
+  keyUp(event) {
+    switch (event.key) {
+      case 'Enter':
+        this.listenerFor('enter')(event);
+        this.listenerFor('insert-newline')(event);
+        break;
+      case 'Escape':
+        this.listenerFor('escape-press')(event);
+        break;
+    }
+  }
+  static {
+    decorateMethodV2(this.prototype, "keyUp", [action]);
+  }
+  listenerFor(name) {
+    let listener = super.listenerFor(name);
+    if (this.isVirtualEventListener(name, listener)) {
+      return devirtualize(listener);
+    } else {
+      return listener;
+    }
+  }
+  isVirtualEventListener(name, _listener) {
+    let virtualEvents = ['enter', 'insert-newline', 'escape-press'];
+    return virtualEvents.indexOf(name) !== -1;
+  }
+}
+
+/**
+@module @ember/component
+*/
+let isValidInputType;
+if (hasDOM) {
+  const INPUT_TYPES = Object.create(null);
+  const INPUT_ELEMENT = document.createElement('input');
+  INPUT_TYPES[''] = false;
+  INPUT_TYPES['text'] = true;
+  INPUT_TYPES['checkbox'] = true;
+  isValidInputType = type => {
+    let isValid = INPUT_TYPES[type];
+    if (isValid === undefined) {
+      try {
+        INPUT_ELEMENT.type = type;
+        isValid = INPUT_ELEMENT.type === type;
+      } catch (_e) {
+        isValid = false;
+      } finally {
+        INPUT_ELEMENT.type = 'text';
+      }
+      INPUT_TYPES[type] = isValid;
+    }
+    return isValid;
+  };
+} else {
+  isValidInputType = type => type !== '';
+}
+
+/**
+  See [Ember.Templates.components.Input](/ember/release/classes/Ember.Templates.components/methods/Input?anchor=Input).
+
+  @method input
+  @for Ember.Templates.helpers
+  @param {Hash} options
+  @public
+  */
+
+/**
+  An opaque interface which can be imported and used in strict-mode
+  templates to call <Input>.
+
+  See [Ember.Templates.components.Input](/ember/release/classes/Ember.Templates.components/methods/Input?anchor=Input).
+
+  @for @ember/component
+  @method Input
+  @see {Ember.Templates.components.Input}
+  @public
+**/
+
+/**
+  The `Input` component lets you create an HTML `<input>` element.
+
+  ```handlebars
+  <Input @value="987" />
+  ```
+
+  creates an `<input>` element with `type="text"` and value set to 987.
+
+  ### Text field
+
+  If no `type` argument is specified, a default of type 'text' is used.
+
+  ```handlebars
+  Search:
+  <Input @value={{this.searchWord}} />
+  ```
+
+  In this example, the initial value in the `<input>` will be set to the value of
+  `this.searchWord`. If the user changes the text, the value of `this.searchWord` will also be
+  updated.
+
+  ### Actions
+
+  The `Input` component takes a number of arguments with callbacks that are invoked in response to
+  user events.
+
+  * `enter`
+  * `insert-newline`
+  * `escape-press`
+  * `focus-in`
+  * `focus-out`
+  * `key-down`
+  * `key-press`
+  * `key-up`
+
+  These callbacks are passed to `Input` like this:
+
+  ```handlebars
+  <Input @value={{this.searchWord}} @enter={{this.query}} />
+  ```
+
+  Starting with Ember Octane, we recommend using the `{{on}}` modifier to call actions
+  on specific events, such as the input event.
+
+  ```handlebars
+  <label for="input-name">Name:</label>
+  <Input
+    @id="input-name"
+    @value={{this.name}}
+    {{on "input" this.validateName}}
+  />
+  ```
+
+  The event name (e.g. `focusout`, `input`, `keydown`) always follows the casing
+  that the HTML standard uses.
+
+  ### `<input>` HTML Attributes to Avoid
+
+  In most cases, if you want to pass an attribute to the underlying HTML `<input>` element, you
+  can pass the attribute directly, just like any other Ember component.
+
+  ```handlebars
+  <Input @type="text" size="10" />
+  ```
+
+  In this example, the `size` attribute will be applied to the underlying `<input>` element in the
+  outputted HTML.
+
+  However, there are a few attributes where you **must** use the `@` version.
+
+  * `@type`: This argument is used to control which Ember component is used under the hood
+  * `@value`: The `@value` argument installs a two-way binding onto the element. If you wanted a
+    one-way binding, use `<input>` with the `value` property and the `input` event instead.
+  * `@checked` (for checkboxes): like `@value`, the `@checked` argument installs a two-way binding
+    onto the element. If you wanted a one-way binding, use `<input type="checkbox">` with
+    `checked` and the `input` event instead.
+
+  ### Checkbox
+
+  To create an `<input type="checkbox">`:
+
+  ```handlebars
+  Emberize Everything:
+  <Input @type="checkbox" @checked={{this.isEmberized}} name="isEmberized" />
+  ```
+
+  This will bind the checked state of this checkbox to the value of `isEmberized` -- if either one
+  changes, it will be reflected in the other.
+
+  @method Input
+  @for Ember.Templates.components
+  @param {Hash} options
+  @public
+*/
+class _Input extends AbstractInput {
+  static toString() {
+    return 'Input';
+  }
+
+  /**
+   * The HTML class attribute.
+   */
+  get class() {
+    if (this.isCheckbox) {
+      return 'ember-checkbox ember-view';
+    } else {
+      return 'ember-text-field ember-view';
+    }
+  }
+
+  /**
+   * The HTML type attribute.
+   */
+  get type() {
+    let type = this.named('type');
+    if (type === null || type === undefined) {
+      return 'text';
+    }
+    (!(typeof type === 'string') && assert('The `@type` argument to the <Input> component must be a string', typeof type === 'string'));
+    return isValidInputType(type) ? type : 'text';
+  }
+  get isCheckbox() {
+    return this.named('type') === 'checkbox';
+  }
+  _checked = valueFrom(this.args.named['checked']);
+  get checked() {
+    if (this.isCheckbox) {
+      (warn('`<Input @type="checkbox" />` reflects its checked state via the `@checked` argument. ' + 'You wrote `<Input @type="checkbox" @value={{...}} />` which is likely not what you intended. ' + 'Did you mean `<Input @type="checkbox" @checked={{...}} />`?', untrack(() => this.args.named['checked'] !== undefined || this.args.named['value'] === undefined || typeof valueForRef(this.args.named['value']) === 'string'), {
+        id: 'ember.built-in-components.input-checkbox-value'
+      }));
+      return this._checked.get();
+    } else {
+      return undefined;
+    }
+  }
+  set checked(checked) {
+    (warn('`<Input @type="checkbox" />` reflects its checked state via the `@checked` argument. ' + 'You wrote `<Input @type="checkbox" @value={{...}} />` which is likely not what you intended. ' + 'Did you mean `<Input @type="checkbox" @checked={{...}} />`?', untrack(() => this.args.named['checked'] !== undefined || this.args.named['value'] === undefined || typeof valueForRef(this.args.named['value']) === 'string'), {
+      id: 'ember.built-in-components.input-checkbox-value'
+    }));
+    this._checked.set(checked);
+  }
+  change(event) {
+    if (this.isCheckbox) {
+      this.checkedDidChange(event);
+    } else {
+      super.change(event);
+    }
+  }
+  static {
+    decorateMethodV2(this.prototype, "change", [action]);
+  }
+  input(event) {
+    if (!this.isCheckbox) {
+      super.input(event);
+    }
+  }
+  static {
+    decorateMethodV2(this.prototype, "input", [action]);
+  }
+  checkedDidChange(event) {
+    let element = event.target;
+    (!(element instanceof HTMLInputElement) && assert('[BUG] element must be an <input>', element instanceof HTMLInputElement));
+    this.checked = element.checked;
+  }
+  static {
+    decorateMethodV2(this.prototype, "checkedDidChange", [action]);
+  }
+  isSupportedArgument(name) {
+    let supportedArguments = ['type', 'value', 'checked', 'enter', 'insert-newline', 'escape-press'];
+    return supportedArguments.indexOf(name) !== -1 || super.isSupportedArgument(name);
+  }
+}
+const Input = opaquify(_Input, InputTemplate);
+
+const TextareaTemplate = templateFactory(
+/*
+  <textarea
+  {{!-- for compatibility --}}
+  id={{this.id}}
+  class={{this.class}}
+
+  ...attributes
+
+  value={{this.value}}
+
+  {{on "change" this.change}}
+  {{on "input" this.input}}
+  {{on "keyup" this.keyUp}}
+  {{on "paste" this.valueDidChange}}
+  {{on "cut" this.valueDidChange}}
+/>
+*/
+{
+  "id": null,
+  "block": "[[[11,\"textarea\"],[16,1,[30,0,[\"id\"]]],[16,0,[30,0,[\"class\"]]],[17,1],[16,2,[30,0,[\"value\"]]],[4,[32,0],[\"change\",[30,0,[\"change\"]]],null],[4,[32,0],[\"input\",[30,0,[\"input\"]]],null],[4,[32,0],[\"keyup\",[30,0,[\"keyUp\"]]],null],[4,[32,0],[\"paste\",[30,0,[\"valueDidChange\"]]],null],[4,[32,0],[\"cut\",[30,0,[\"valueDidChange\"]]],null],[12],[13]],[\"&attrs\"],[]]",
+  "moduleName": "packages/@ember/-internals/glimmer/lib/templates/textarea.hbs",
+  "scope": () => ({
+    on
+  }),
+  "isStrictMode": true
+});
+
+/**
+@module @ember/component
+*/
+
+class _Textarea extends AbstractInput {
+  static toString() {
+    return 'Textarea';
+  }
+  get class() {
+    return 'ember-text-area ember-view';
+  }
+
+  // See abstract-input.ts for why these are needed
+
+  change(event) {
+    super.change(event);
+  }
+  static {
+    decorateMethodV2(this.prototype, "change", [action]);
+  }
+  input(event) {
+    super.input(event);
+  }
+  static {
+    decorateMethodV2(this.prototype, "input", [action]);
+  }
+  isSupportedArgument(name) {
+    let supportedArguments = ['type', 'value', 'enter', 'insert-newline', 'escape-press'];
+    return supportedArguments.indexOf(name) !== -1 || super.isSupportedArgument(name);
+  }
+}
+const Textarea = opaquify(_Textarea, TextareaTemplate);
+
+export { Input as I, Textarea as T };

package/dist/dev/packages/shared-chunks/tracked-CKE4wnE6.js

@@ -0,0 +1,148 @@
+import { meta } from '../@ember/-internals/meta/lib/meta.js';
+import { isEmberArray } from '../@ember/array/-internals.js';
+import '../@ember/debug/index.js';
+import { k as consumeTag } from './cache-B7dqAS38.js';
+import { d as dirtyTagFor, t as tagFor } from './meta-BmRXesrk.js';
+import { t as trackedData } from './tracked-data-CGnA4ytZ.js';
+import { S as SELF_TAG, C as CHAIN_PASS_THROUGH } from './chain-tags-D6tuFUj_.js';
+import { s as setClassicDecorator, i as isElementDescriptor, C as COMPUTED_SETTERS } from './decorator-B5Uh5NFI.js';
+import { assert } from '../@ember/debug/lib/assert.js';
+
+/**
+  @decorator
+  @private
+
+  Marks a property as tracked.
+
+  By default, a component's properties are expected to be static,
+  meaning you are not able to update them and have the template update accordingly.
+  Marking a property as tracked means that when that property changes,
+  a rerender of the component is scheduled so the template is kept up to date.
+
+  There are two usages for the `@tracked` decorator, shown below.
+
+  @example No dependencies
+
+  If you don't pass an argument to `@tracked`, only changes to that property
+  will be tracked:
+
+  ```typescript
+  import Component from '@glimmer/component';
+  import { tracked } from '@glimmer/tracking';
+
+  export default class MyComponent extends Component {
+    @tracked
+    remainingApples = 10
+  }
+  ```
+
+  When something changes the component's `remainingApples` property, the rerender
+  will be scheduled.
+
+  @example Dependents
+
+  In the case that you have a computed property that depends other
+  properties, you want to track both so that when one of the
+  dependents change, a rerender is scheduled.
+
+  In the following example we have two properties,
+  `eatenApples`, and `remainingApples`.
+
+  ```typescript
+  import Component from '@glimmer/component';
+  import { tracked } from '@glimmer/tracking';
+
+  const totalApples = 100;
+
+  export default class MyComponent extends Component {
+    @tracked
+    eatenApples = 0
+
+    get remainingApples() {
+      return totalApples - this.eatenApples;
+    }
+
+    increment() {
+      this.eatenApples = this.eatenApples + 1;
+    }
+  }
+  ```
+
+  @param dependencies Optional dependents to be tracked.
+*/
+
+function tracked(...args) {
+  (!(!(isElementDescriptor(args.slice(0, 3)) && args.length === 5 && args[4] === true)) && assert(`@tracked can only be used directly as a native decorator. If you're using tracked in classic classes, add parenthesis to call it like a function: tracked()`, !(isElementDescriptor(args.slice(0, 3)) && args.length === 5 && args[4] === true)));
+  if (!isElementDescriptor(args)) {
+    let propertyDesc = args[0];
+    (!(args.length === 0 || typeof propertyDesc === 'object' && propertyDesc !== null) && assert(`tracked() may only receive an options object containing 'value' or 'initializer', received ${propertyDesc}`, args.length === 0 || typeof propertyDesc === 'object' && propertyDesc !== null));
+    if (propertyDesc) {
+      let keys = Object.keys(propertyDesc);
+      (!(keys.length <= 1 && (keys[0] === undefined || keys[0] === 'value' || keys[0] === 'initializer')) && assert(`The options object passed to tracked() may only contain a 'value' or 'initializer' property, not both. Received: [${keys}]`, keys.length <= 1 && (keys[0] === undefined || keys[0] === 'value' || keys[0] === 'initializer')));
+      (!(!('initializer' in propertyDesc) || typeof propertyDesc.initializer === 'function') && assert(`The initializer passed to tracked must be a function. Received ${propertyDesc.initializer}`, !('initializer' in propertyDesc) || typeof propertyDesc.initializer === 'function'));
+    }
+    let initializer = propertyDesc ? propertyDesc.initializer : undefined;
+    let value = propertyDesc ? propertyDesc.value : undefined;
+    let decorator = function (target, key, _desc, _meta, isClassicDecorator) {
+      (!(isClassicDecorator) && assert(`You attempted to set a default value for ${key} with the @tracked({ value: 'default' }) syntax. You can only use this syntax with classic classes. For native classes, you can use class initializers: @tracked field = 'default';`, isClassicDecorator));
+      let fieldDesc = {
+        initializer: initializer || (() => value)
+      };
+      return descriptorForField([target, key, fieldDesc]);
+    };
+    setClassicDecorator(decorator);
+    return decorator;
+  }
+  return descriptorForField(args);
+}
+{
+  // Normally this isn't a classic decorator, but we want to throw a helpful
+  // error in development so we need it to treat it like one
+  setClassicDecorator(tracked);
+}
+function descriptorForField([target, key, desc]) {
+  (!(!desc || !desc.value && !desc.get && !desc.set) && assert(`You attempted to use @tracked on ${key}, but that element is not a class field. @tracked is only usable on class fields. Native getters and setters will autotrack add any tracked fields they encounter, so there is no need mark getters and setters with @tracked.`, !desc || !desc.value && !desc.get && !desc.set));
+  let {
+    getter,
+    setter
+  } = trackedData(key, desc ? desc.initializer : undefined);
+  function get() {
+    let value = getter(this);
+
+    // Add the tag of the returned value if it is an array, since arrays
+    // should always cause updates if they are consumed and then changed
+    if (Array.isArray(value) || isEmberArray(value)) {
+      consumeTag(tagFor(value, '[]'));
+    }
+    return value;
+  }
+  function set(newValue) {
+    setter(this, newValue);
+    dirtyTagFor(this, SELF_TAG);
+  }
+  let newDesc = {
+    enumerable: true,
+    configurable: true,
+    isTracked: true,
+    get,
+    set
+  };
+  COMPUTED_SETTERS.add(set);
+  meta(target).writeDescriptors(key, new TrackedDescriptor(get, set));
+  return newDesc;
+}
+class TrackedDescriptor {
+  constructor(_get, _set) {
+    this._get = _get;
+    this._set = _set;
+    CHAIN_PASS_THROUGH.add(this);
+  }
+  get(obj) {
+    return this._get.call(obj);
+  }
+  set(obj, _key, value) {
+    this._set.call(obj, value);
+  }
+}
+
+export { TrackedDescriptor as T, tracked as t };

package/dist/dev/packages/shared-chunks/tracked-data-CGnA4ytZ.js

@@ -0,0 +1,31 @@
+import { d as dirtyTagFor, t as tagFor } from './meta-BmRXesrk.js';
+import { k as consumeTag } from './cache-B7dqAS38.js';
+
+function trackedData(key, initializer) {
+  let values = new WeakMap();
+  let hasInitializer = typeof initializer === 'function';
+  function getter(self) {
+    consumeTag(tagFor(self, key));
+    let value;
+
+    // If the field has never been initialized, we should initialize it
+    if (hasInitializer && !values.has(self)) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+      value = initializer.call(self);
+      values.set(self, value);
+    } else {
+      value = values.get(self);
+    }
+    return value;
+  }
+  function setter(self, value) {
+    dirtyTagFor(self, key);
+    values.set(self, value);
+  }
+  return {
+    getter,
+    setter
+  };
+}
+
+export { trackedData as t };