ember-source 6.12.0 → 7.0.0-beta.1

package/dist/prod/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.js

@@ -0,0 +1,42 @@
+import '../../../environment/index.js';
+import Mixin from '../../../../object/mixin.js';
+
+/**
+@module ember
+*/
+
+
+/**
+  RegistryProxyMixin is used to provide public access to specific
+  registry functionality.
+
+  @class RegistryProxyMixin
+  @extends RegistryProxy
+  @private
+*/
+
+const RegistryProxyMixin = Mixin.create({
+  __registry__: null,
+  resolveRegistration(fullName) {
+    return this.__registry__.resolve(fullName);
+  },
+  register: registryAlias('register'),
+  unregister: registryAlias('unregister'),
+  hasRegistration: registryAlias('has'),
+  registeredOption: registryAlias('getOption'),
+  registerOptions: registryAlias('options'),
+  registeredOptions: registryAlias('getOptions'),
+  registerOptionsForType: registryAlias('optionsForType'),
+  registeredOptionsForType: registryAlias('getOptionsForType')
+});
+function registryAlias(name) {
+  return function (...args) {
+    // We need this cast because `Parameters` is deferred so that it is not
+    // possible for TS to see it will always produce the right type. However,
+    // since `AnyFn` has a rest type, it is allowed. See discussion on [this
+    // issue](https://github.com/microsoft/TypeScript/issues/47615).
+    return this.__registry__[name](...args);
+  };
+}
+
+export { RegistryProxyMixin as default };

package/dist/prod/packages/@ember/-internals/runtime/lib/mixins/target_action_support.js

@@ -0,0 +1,142 @@
+import { context } from '../../../environment/index.js';
+import { c as computed } from '../../../../../shared-chunks/namespace_search-Aog9nySA.js';
+import '../../../../../shared-chunks/super-Cm_a_cLQ.js';
+import '../../../../../@glimmer/validator/index.js';
+import '../../../../../shared-chunks/reference-BNqcwZWH.js';
+import '../../../../../shared-chunks/capabilities-DGmQ_mz4.js';
+import { g as get } from '../../../../../shared-chunks/observers-R1ZklwWy.js';
+import Mixin from '../../../../object/mixin.js';
+
+/**
+@module ember
+*/
+
+
+/**
+`TargetActionSupport` is a mixin that can be included in a class
+to add a `triggerAction` method with semantics similar to the Handlebars
+`{{action}}` helper. In normal Ember usage, the `{{action}}` helper is
+usually the best choice. This mixin is most often useful when you are
+doing more complex event handling in Components.
+
+@class TargetActionSupport
+@namespace Ember
+@extends Mixin
+@private
+*/
+
+const TargetActionSupport = Mixin.create({
+  target: null,
+  action: null,
+  actionContext: null,
+  actionContextObject: computed('actionContext', function () {
+    let actionContext = get(this, 'actionContext');
+    if (typeof actionContext === 'string') {
+      let value = get(this, actionContext);
+      if (value === undefined) {
+        value = get(context.lookup, actionContext);
+      }
+      return value;
+    } else {
+      return actionContext;
+    }
+  }),
+  /**
+  The following is private and vestigial.
+  Send an `action` with an `actionContext` to a `target`. The action, actionContext
+  and target will be retrieved from properties of the object. For example:
+   ```javascript
+  import { alias } from '@ember/object/computed';
+   App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
+    target: alias('controller'),
+    action: 'save',
+    actionContext: alias('context'),
+    click() {
+      this.triggerAction(); // Sends the `save` action, along with the current context
+                            // to the current controller
+    }
+  });
+  ```
+   The `target`, `action`, and `actionContext` can be provided as properties of
+  an optional object argument to `triggerAction` as well.
+   ```javascript
+  App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
+    click() {
+      this.triggerAction({
+        action: 'save',
+        target: this.get('controller'),
+        actionContext: this.get('context')
+      }); // Sends the `save` action, along with the current context
+          // to the current controller
+    }
+  });
+  ```
+   The `actionContext` defaults to the object you are mixing `TargetActionSupport` into.
+  But `target` and `action` must be specified either as properties or with the argument
+  to `triggerAction`, or a combination:
+   ```javascript
+  import { alias } from '@ember/object/computed';
+   App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
+    target: alias('controller'),
+    click() {
+      this.triggerAction({
+        action: 'save'
+      }); // Sends the `save` action, along with a reference to `this`,
+          // to the current controller
+    }
+  });
+  ```
+   @method triggerAction
+  @param opts {Object} (optional, with the optional keys action, target and/or actionContext)
+  @return {Boolean} true if the action was sent successfully and did not return false
+  @private
+  */
+  triggerAction(opts = {}) {
+    let {
+      action,
+      target,
+      actionContext
+    } = opts;
+    action = action || get(this, 'action');
+    target = target || getTarget(this);
+    if (actionContext === undefined) {
+      actionContext = get(this, 'actionContextObject') || this;
+    }
+    let context = Array.isArray(actionContext) ? actionContext : [actionContext];
+    if (target && action) {
+      let ret;
+      if (isSendable(target)) {
+        ret = target.send(action, ...context);
+      } else {
+        ret = target[action](...context);
+      }
+      if (ret !== false) {
+        return true;
+      }
+    }
+    return false;
+  }
+});
+function isSendable(obj) {
+  return obj != null && typeof obj === 'object' && typeof obj.send === 'function';
+}
+function getTarget(instance) {
+  let target = get(instance, 'target');
+  if (target) {
+    if (typeof target === 'string') {
+      let value = get(instance, target);
+      if (value === undefined) {
+        value = get(context.lookup, target);
+      }
+      return value;
+    } else {
+      return target;
+    }
+  }
+  if (instance._target) {
+    return instance._target;
+  }
+  return null;
+}
+
+export { TargetActionSupport as default };

package/dist/prod/packages/@ember/-internals/string/index.js

@@ -0,0 +1,93 @@
+import '../../../shared-chunks/super-Cm_a_cLQ.js';
+import { C as Cache } from '../../../shared-chunks/cache-qDyqAcpg.js';
+import '../environment/index.js';
+
+/*
+  This module exists to separate the @ember/string methods used
+  internally in ember-source, from those public methods that are
+  now deprecated and to be removed.
+*/
+
+const STRING_DASHERIZE_REGEXP = /[ _]/g;
+const STRING_DASHERIZE_CACHE = new Cache(1000, key => decamelize(key).replace(STRING_DASHERIZE_REGEXP, '-'));
+const STRING_CLASSIFY_REGEXP_1 = /^(-|_)+(.)?/;
+const STRING_CLASSIFY_REGEXP_2 = /(.)(-|_|\.|\s)+(.)?/g;
+const STRING_CLASSIFY_REGEXP_3 = /(^|\/|\.)([a-z])/g;
+const CLASSIFY_CACHE = new Cache(1000, str => {
+  let replace1 = (_match, _separator, chr) => chr ? `_${chr.toUpperCase()}` : '';
+  let replace2 = (_match, initialChar, _separator, chr) => initialChar + (chr ? chr.toUpperCase() : '');
+  let parts = str.split('/');
+  for (let i = 0; i < parts.length; i++) {
+    parts[i] = parts[i].replace(STRING_CLASSIFY_REGEXP_1, replace1).replace(STRING_CLASSIFY_REGEXP_2, replace2);
+  }
+  return parts.join('/').replace(STRING_CLASSIFY_REGEXP_3, (match /*, separator, chr */) => match.toUpperCase());
+});
+const STRING_DECAMELIZE_REGEXP = /([a-z\d])([A-Z])/g;
+const DECAMELIZE_CACHE = new Cache(1000, str => str.replace(STRING_DECAMELIZE_REGEXP, '$1_$2').toLowerCase());
+
+/**
+ Defines string helper methods used internally in ember-source.
+
+ @class String
+ @private
+ */
+
+/**
+ Replaces underscores, spaces, or camelCase with dashes.
+
+ ```javascript
+ import { dasherize } from '@ember/-internals/string';
+
+ dasherize('innerHTML');                // 'inner-html'
+ dasherize('action_name');              // 'action-name'
+ dasherize('css-class-name');           // 'css-class-name'
+ dasherize('my favorite items');        // 'my-favorite-items'
+ dasherize('privateDocs/ownerInvoice';  // 'private-docs/owner-invoice'
+ ```
+
+ @method dasherize
+ @param {String} str The string to dasherize.
+ @return {String} the dasherized string.
+ @private
+ */
+function dasherize(str) {
+  return STRING_DASHERIZE_CACHE.get(str);
+}
+
+/**
+ Returns the UpperCamelCase form of a string.
+
+ ```javascript
+ import { classify } from '@ember/string';
+
+ classify('innerHTML');                   // 'InnerHTML'
+ classify('action_name');                 // 'ActionName'
+ classify('css-class-name');              // 'CssClassName'
+ classify('my favorite items');           // 'MyFavoriteItems'
+ classify('private-docs/owner-invoice');  // 'PrivateDocs/OwnerInvoice'
+ ```
+
+ @method classify
+ @param {String} str the string to classify
+ @return {String} the classified string
+ @private
+ */
+function classify(str) {
+  return CLASSIFY_CACHE.get(str);
+}
+
+/**
+ Converts a camelized string into all lower case separated by underscores.
+
+ ```javascript
+ decamelize('innerHTML');          // 'inner_html'
+ decamelize('action_name');        // 'action_name'
+ decamelize('css-class-name');     // 'css-class-name'
+ decamelize('my favorite items');  // 'my favorite items'
+ ```
+ */
+function decamelize(str) {
+  return DECAMELIZE_CACHE.get(str);
+}
+
+export { classify, dasherize };

package/dist/prod/packages/@ember/-internals/utility-types/index.js

@@ -0,0 +1,12 @@
+// The formatting here is designed to help make this type actually be
+// comprehensible to mortals, including the mortals who came up with it.
+// prettier-ignore
+
+// A way of representing non-user-constructible types. You can conveniently use
+// this by doing `interface Type extends Opaque<'some-type-name'> { ... }` for
+// simple types, and/or you can type-parameterize it as makes sense for your use
+// case (see e.g. `@ember/component/helper`'s use with functional helpers).
+
+class Opaque {}
+
+export { Opaque };

package/dist/prod/packages/@ember/-internals/utils/index.js

@@ -0,0 +1,75 @@
+export { m as dictionary } from '../../../shared-chunks/dictionary-gc5gpyOG.js';
+export { g as getDebugName } from '../../../shared-chunks/get-debug-name-BDxIL2Y1.js';
+export { G as GUID_KEY, R as ROOT, c as checkHasSuper, a as generateGuid, g as guidFor, b as intern, i as isObject, o as observerListenerMetaFor, d as setListeners, s as setObservers, u as uuid, w as wrap } from '../../../shared-chunks/super-Cm_a_cLQ.js';
+export { l as lookupDescriptor } from '../../../shared-chunks/lookup-descriptor-CwcVgaLv.js';
+export { g as getName, s as setName } from '../../../shared-chunks/name-C68GLLO3.js';
+export { i as isProxy, s as setProxy } from '../../../shared-chunks/is_proxy-Cr1qlMv_.js';
+export { C as Cache } from '../../../shared-chunks/cache-qDyqAcpg.js';
+import '../environment/index.js';
+
+/**
+  Checks to see if the `methodName` exists on the `obj`.
+
+  ```javascript
+  let foo = { bar: function() { return 'bar'; }, baz: null };
+
+  Ember.canInvoke(foo, 'bar'); // true
+  Ember.canInvoke(foo, 'baz'); // false
+  Ember.canInvoke(foo, 'bat'); // false
+  ```
+
+  @method canInvoke
+  @for Ember
+  @param {Object} obj The object to check for the method
+  @param {String} methodName The method name to check for
+  @return {Boolean}
+  @private
+*/
+function canInvoke(obj, methodName) {
+  return obj != null && typeof obj[methodName] === 'function';
+}
+
+/**
+  @module @ember/utils
+*/
+
+const objectToString = Object.prototype.toString;
+function isNone(obj) {
+  return obj === null || obj === undefined;
+}
+
+/*
+ A `toString` util function that supports objects without a `toString`
+ method, e.g. an object created with `Object.create(null)`.
+*/
+function toString(obj) {
+  if (typeof obj === 'string') {
+    return obj;
+  }
+  if (null === obj) return 'null';
+  if (undefined === obj) return 'undefined';
+  if (Array.isArray(obj)) {
+    // Reimplement Array.prototype.join according to spec (22.1.3.13)
+    // Changing ToString(element) with this safe version of ToString.
+    let r = '';
+    for (let k = 0; k < obj.length; k++) {
+      if (k > 0) {
+        r += ',';
+      }
+      if (!isNone(obj[k])) {
+        r += toString(obj[k]);
+      }
+    }
+    return r;
+  }
+  if (typeof obj.toString === 'function') {
+    return obj.toString();
+  }
+  return objectToString.call(obj);
+}
+
+let setupMandatorySetter;
+let teardownMandatorySetter;
+let setWithMandatorySetter;
+
+export { canInvoke, setWithMandatorySetter, setupMandatorySetter, teardownMandatorySetter, toString };

package/dist/prod/packages/@ember/-internals/views/index.js

@@ -0,0 +1,7 @@
+export { addChildView, clearElementView, clearViewElement, constructStyleDeprecationMessage, getChildViews, getElementView, getRootViews, getViewBoundingClientRect, getViewBounds, getViewClientRects, getViewElement, getViewId, isSimpleClick, setElementView, setViewElement } from './lib/system/utils.js';
+export { default as EventDispatcher } from './lib/system/event_dispatcher.js';
+export { default as ComponentLookup } from './lib/component_lookup.js';
+export { default as CoreView } from './lib/views/core_view.js';
+export { default as ActionSupport } from './lib/mixins/action_support.js';
+export { MUTABLE_CELL } from './lib/compat/attrs.js';
+export { default as ViewStates } from './lib/views/states.js';

package/dist/prod/packages/@ember/-internals/views/lib/compat/attrs.js

@@ -0,0 +1,3 @@
+const MUTABLE_CELL = Symbol('MUTABLE_CELL');
+
+export { MUTABLE_CELL };

package/dist/prod/packages/@ember/-internals/views/lib/compat/fallback-view-registry.js

@@ -0,0 +1,7 @@
+import { m as makeDictionary } from '../../../../../shared-chunks/dictionary-gc5gpyOG.js';
+import '../../../../../shared-chunks/super-Cm_a_cLQ.js';
+import '../../../environment/index.js';
+
+const fallbackViewRegistry = makeDictionary(null);
+
+export { fallbackViewRegistry as default };

package/dist/prod/packages/@ember/-internals/views/lib/component_lookup.js

@@ -0,0 +1,14 @@
+import EmberObject from '../../../object/index.js';
+
+class ComponentLookup extends EmberObject {
+  componentFor(name, owner) {
+    let fullName = `component:${name}`;
+    return owner.factoryFor(fullName);
+  }
+  layoutFor(name, owner, options) {
+    let templateFullName = `template:components/${name}`;
+    return owner.lookup(templateFullName, options);
+  }
+}
+
+export { ComponentLookup as default };

package/dist/prod/packages/@ember/-internals/views/lib/mixins/action_support.js

@@ -0,0 +1,35 @@
+import '../../../../../shared-chunks/super-Cm_a_cLQ.js';
+import '../../../environment/index.js';
+import '../../../../../@glimmer/validator/index.js';
+import '../../../../../shared-chunks/reference-BNqcwZWH.js';
+import '../../../../../shared-chunks/capabilities-DGmQ_mz4.js';
+import { g as get } from '../../../../../shared-chunks/observers-R1ZklwWy.js';
+import Mixin from '../../../../object/mixin.js';
+
+/**
+ @module ember
+*/
+
+/**
+ @class ActionSupport
+ @namespace Ember
+ @private
+*/
+
+const ActionSupport = Mixin.create({
+  send(actionName, ...args) {
+    let action = this.actions && this.actions[actionName];
+    if (action) {
+      let shouldBubble = action.apply(this, args) === true;
+      if (!shouldBubble) {
+        return;
+      }
+    }
+    let target = get(this, 'target');
+    if (target) {
+      target.send(...arguments);
+    }
+  }
+});
+
+export { ActionSupport as default };

package/dist/prod/packages/@ember/-internals/views/lib/system/event_dispatcher.js

@@ -0,0 +1,227 @@
+import '../../../environment/index.js';
+import '../../../../../shared-chunks/super-Cm_a_cLQ.js';
+import '../../../../../@glimmer/validator/index.js';
+import '../../../../../shared-chunks/reference-BNqcwZWH.js';
+import '../../../../../shared-chunks/capabilities-DGmQ_mz4.js';
+import { g as get } from '../../../../../shared-chunks/observers-R1ZklwWy.js';
+import { s as set } from '../../../../../shared-chunks/property_set-O080KTKZ.js';
+import EmberObject from '../../../../object/index.js';
+import { getElementView } from './utils.js';
+
+/**
+@module ember
+*/
+
+const ROOT_ELEMENT_CLASS = 'ember-application';
+
+/**
+  `EventDispatcher` handles delegating browser events to their
+  corresponding `Ember.Views.` For example, when you click on a view,
+  `EventDispatcher` ensures that that view's `mouseDown` method gets
+  called.
+
+  @class EventDispatcher
+  @namespace Ember
+  @private
+  @extends EmberObject
+*/
+class EventDispatcher extends EmberObject {
+  /**
+    The set of events names (and associated handler function names) to be setup
+    and dispatched by the `EventDispatcher`. Modifications to this list can be done
+    at setup time, generally via the `Application.customEvents` hash.
+     To add new events to be listened to:
+     ```javascript
+    import Application from '@ember/application';
+     let App = Application.create({
+      customEvents: {
+        paste: 'paste'
+      }
+    });
+    ```
+     To prevent default events from being listened to:
+     ```javascript
+    import Application from '@ember/application';
+     let App = Application.create({
+      customEvents: {
+        mouseenter: null,
+        mouseleave: null
+      }
+    });
+    ```
+    @property events
+    @type Object
+    @private
+  */
+  events = {
+    touchstart: 'touchStart',
+    touchmove: 'touchMove',
+    touchend: 'touchEnd',
+    touchcancel: 'touchCancel',
+    keydown: 'keyDown',
+    keyup: 'keyUp',
+    keypress: 'keyPress',
+    mousedown: 'mouseDown',
+    mouseup: 'mouseUp',
+    contextmenu: 'contextMenu',
+    click: 'click',
+    dblclick: 'doubleClick',
+    focusin: 'focusIn',
+    focusout: 'focusOut',
+    submit: 'submit',
+    input: 'input',
+    change: 'change',
+    dragstart: 'dragStart',
+    drag: 'drag',
+    dragenter: 'dragEnter',
+    dragleave: 'dragLeave',
+    dragover: 'dragOver',
+    drop: 'drop',
+    dragend: 'dragEnd'
+  };
+
+  /**
+    The root DOM element to which event listeners should be attached. Event
+    listeners will be attached to the document unless this is overridden.
+     Can be specified as a DOMElement or a selector string.
+     The default body is a string since this may be evaluated before document.body
+    exists in the DOM.
+     @private
+    @property rootElement
+    @type DOMElement
+    @default 'body'
+  */
+  rootElement = 'body';
+  _eventHandlers = Object.create(null);
+  _didSetup = false;
+  finalEventNameMapping = null;
+  _sanitizedRootElement = null;
+  lazyEvents = new Map();
+  _reverseEventNameMapping = null;
+
+  /**
+    Sets up event listeners for standard browser events.
+     This will be called after the browser sends a `DOMContentReady` event. By
+    default, it will set up all of the listeners on the document body. If you
+    would like to register the listeners on a different element, set the event
+    dispatcher's `root` property.
+     @private
+    @method setup
+    @param addedEvents {Object}
+  */
+  setup(addedEvents, _rootElement) {
+    let events = this.finalEventNameMapping = {
+      ...get(this, 'events'),
+      ...addedEvents
+    };
+    this._reverseEventNameMapping = Object.keys(events).reduce((result, key) => {
+      let eventName = events[key];
+      return eventName ? {
+        ...result,
+        [eventName]: key
+      } : result;
+    }, {});
+    let lazyEvents = this.lazyEvents;
+    if (_rootElement !== undefined && _rootElement !== null) {
+      set(this, 'rootElement', _rootElement);
+    }
+    let specifiedRootElement = get(this, 'rootElement');
+    let rootElement = typeof specifiedRootElement !== 'string' ? specifiedRootElement : document.querySelector(specifiedRootElement);
+    rootElement.classList.add(ROOT_ELEMENT_CLASS);
+    this._sanitizedRootElement = rootElement;
+
+    // setup event listeners for the non-lazily setup events
+    for (let event in events) {
+      if (Object.prototype.hasOwnProperty.call(events, event)) {
+        lazyEvents.set(event, events[event] ?? null);
+      }
+    }
+    this._didSetup = true;
+  }
+
+  /**
+    Setup event listeners for the given browser event name
+     @private
+    @method setupHandlerForBrowserEvent
+    @param event the name of the event in the browser
+  */
+  setupHandlerForBrowserEvent(event) {
+    this.setupHandler(this._sanitizedRootElement, event, this.finalEventNameMapping[event] ?? null);
+  }
+
+  /**
+    Setup event listeners for the given Ember event name (camel case)
+     @private
+    @method setupHandlerForEmberEvent
+    @param eventName
+  */
+  setupHandlerForEmberEvent(eventName) {
+    let event = this._reverseEventNameMapping?.[eventName];
+    if (event) {
+      this.setupHandler(this._sanitizedRootElement, event, eventName);
+    }
+  }
+
+  /**
+    Registers an event listener on the rootElement. If the given event is
+    triggered, the provided event handler will be triggered on the target view.
+     If the target view does not implement the event handler, or if the handler
+    returns `false`, the parent view will be called. The event will continue to
+    bubble to each successive parent view until it reaches the top.
+     @private
+    @method setupHandler
+    @param {Element} rootElement
+    @param {String} event the name of the event in the browser
+    @param {String} eventName the name of the method to call on the view
+  */
+  setupHandler(rootElement, event, eventName) {
+    if (eventName === null || !this.lazyEvents.has(event)) {
+      return; // nothing to do
+    }
+    let viewHandler = (target, event) => {
+      let view = getElementView(target);
+      let result = true;
+      if (view) {
+        // SAFETY: As currently written, this is not safe. Though it seems to always be true.
+        result = view.handleEvent(eventName, event);
+      }
+      return result;
+    };
+    let handleEvent = this._eventHandlers[event] = event => {
+      let target = event.target;
+      do {
+        if (getElementView(target)) {
+          if (viewHandler(target, event) === false) {
+            event.preventDefault();
+            event.stopPropagation();
+            break;
+          } else if (event.cancelBubble === true) {
+            break;
+          }
+        }
+        target = target.parentNode;
+      } while (target instanceof Element);
+    };
+    rootElement.addEventListener(event, handleEvent);
+    this.lazyEvents.delete(event);
+  }
+  destroy() {
+    if (this._didSetup === false) {
+      return;
+    }
+    let rootElement = this._sanitizedRootElement;
+    if (!rootElement) {
+      return;
+    }
+    for (let event in this._eventHandlers) {
+      rootElement.removeEventListener(event, this._eventHandlers[event]);
+    }
+    rootElement.classList.remove(ROOT_ELEMENT_CLASS);
+    return this._super(...arguments);
+  }
+  toString() {
+    return '(EventDispatcher)';
+  }
+}
+
+export { EventDispatcher as default };