ember-source 7.1.0-alpha.4 → 7.1.0-alpha.5

package/dist/dev/packages/shared-chunks/env-g-kaAFLN.js

@@ -0,0 +1,161 @@
+/**
+  The hash of environment variables used to control various configuration
+  settings. To specify your own or override default settings, add the
+  desired properties to a global hash named `EmberENV` (or `ENV` for
+  backwards compatibility with earlier versions of Ember). The `EmberENV`
+  hash must be created before loading Ember.
+
+  @class EmberENV
+  @type Object
+  @public
+*/
+const ENV = {
+  ENABLE_OPTIONAL_FEATURES: false,
+  /**
+    Determines whether Ember should add to `Array`
+    native object prototypes, a few extra methods in order to provide a more
+    friendly API.
+     The behavior from setting this option to `true` was deprecated in Ember 5.10.
+     @property EXTEND_PROTOTYPES
+    @type Boolean
+    @default true
+    @for EmberENV
+    @private
+    @deprecated in v5.10
+  */
+  EXTEND_PROTOTYPES: {
+    Array: false
+  },
+  /**
+    The `LOG_STACKTRACE_ON_DEPRECATION` property, when true, tells Ember to log
+    a full stack trace during deprecation warnings.
+     @property LOG_STACKTRACE_ON_DEPRECATION
+    @type Boolean
+    @default true
+    @for EmberENV
+    @public
+  */
+  LOG_STACKTRACE_ON_DEPRECATION: true,
+  /**
+    The `LOG_VERSION` property, when true, tells Ember to log versions of all
+    dependent libraries in use.
+     @property LOG_VERSION
+    @type Boolean
+    @default true
+    @for EmberENV
+    @public
+  */
+  LOG_VERSION: true,
+  /**
+    The `LOG_INSPECTOR_HINT` property, when true, tells Ember to log a hint
+    suggesting the Ember Inspector browser extension when it is not detected.
+     @property LOG_INSPECTOR_HINT
+    @type Boolean
+    @default true
+    @for EmberENV
+    @public
+  */
+  LOG_INSPECTOR_HINT: true,
+  RAISE_ON_DEPRECATION: false,
+  STRUCTURED_PROFILE: false,
+  /**
+    Whether to perform extra bookkeeping needed to make the `captureRenderTree`
+    API work.
+     This has to be set before the ember JavaScript code is evaluated. This is
+    usually done by setting `window.EmberENV = { _DEBUG_RENDER_TREE: true };`
+    before the "vendor" `<script>` tag in `index.html`.
+     Setting the flag after Ember is already loaded will not work correctly. It
+    may appear to work somewhat, but fundamentally broken.
+     This is not intended to be set directly. Ember Inspector will enable the
+    flag on behalf of the user as needed.
+     This flag is always on in development mode.
+     The flag is off by default in production mode, due to the cost associated
+    with the the bookkeeping work.
+     The expected flow is that Ember Inspector will ask the user to refresh the
+    page after enabling the feature. It could also offer a feature where the
+    user add some domains to the "always on" list. In either case, Ember
+    Inspector will inject the code on the page to set the flag if needed.
+     @property _DEBUG_RENDER_TREE
+    @for EmberENV
+    @type Boolean
+    @default false
+    @private
+  */
+  _DEBUG_RENDER_TREE: true /* DEBUG */,
+  /**
+   Whether to force all deprecations to be enabled. This is used internally by
+   Ember to enable deprecations in tests. It is not intended to be set in
+   projects.
+    @property _ALL_DEPRECATIONS_ENABLED
+   @for EmberENV
+   @type Boolean
+   @default false
+   @private
+   */
+  _ALL_DEPRECATIONS_ENABLED: false,
+  /**
+   Override the version of ember-source used to determine when deprecations "break".
+   This is used internally by Ember to test with deprecated features "removed".
+   This is never intended to be set by projects.
+   @property _OVERRIDE_DEPRECATION_VERSION
+   @for EmberENV
+   @type string | null
+   @default null
+   @private
+   */
+  _OVERRIDE_DEPRECATION_VERSION: null,
+  /**
+    Whether the app defaults to using async observers.
+     This is not intended to be set directly, as the implementation may change in
+    the future. Use `@ember/optional-features` instead.
+     @property _DEFAULT_ASYNC_OBSERVERS
+    @for EmberENV
+    @type Boolean
+    @default false
+    @private
+  */
+  _DEFAULT_ASYNC_OBSERVERS: false,
+  /**
+    Controls the maximum number of scheduled rerenders without "settling". In general,
+    applications should not need to modify this environment variable, but please
+    open an issue so that we can determine if a better default value is needed.
+     @property _RERENDER_LOOP_LIMIT
+    @for EmberENV
+    @type number
+    @default 1000
+    @private
+   */
+  _RERENDER_LOOP_LIMIT: 1000,
+  FEATURES: {}
+};
+const EmberENV = globalThis.EmberENV;
+if (typeof EmberENV === 'object' && EmberENV !== null) {
+  for (let flag in EmberENV) {
+    if (!Object.prototype.hasOwnProperty.call(EmberENV, flag) || flag === 'EXTEND_PROTOTYPES' || flag === 'EMBER_LOAD_HOOKS') continue;
+    let defaultValue = ENV[flag];
+    if (defaultValue === true) {
+      ENV[flag] = EmberENV[flag] !== false;
+    } else if (defaultValue === false) {
+      ENV[flag] = EmberENV[flag] === true;
+    } else {
+      ENV[flag] = EmberENV[flag];
+    }
+  }
+  let {
+    FEATURES
+  } = EmberENV;
+  if (typeof FEATURES === 'object' && FEATURES !== null) {
+    for (let feature in FEATURES) {
+      if (!Object.prototype.hasOwnProperty.call(FEATURES, feature)) continue;
+      ENV.FEATURES[feature] = FEATURES[feature] === true;
+    }
+  }
+  {
+    ENV._DEBUG_RENDER_TREE = true;
+  }
+}
+function getENV() {
+  return ENV;
+}
+
+export { ENV as E, getENV as g };

package/dist/dev/packages/shared-chunks/events-6aFVjD4k.js

@@ -0,0 +1,180 @@
+import { meta, peekMeta } from '../@ember/-internals/meta/lib/meta.js';
+import { a as setListeners } from './super-BBBjgF69.js';
+import '../@ember/debug/index.js';
+import { assert } from '../@ember/debug/lib/assert.js';
+
+/**
+@module @ember/object
+*/
+
+
+/*
+  The event system uses a series of nested hashes to store listeners on an
+  object. When a listener is registered, or when an event arrives, these
+  hashes are consulted to determine which target and action pair to invoke.
+
+  The hashes are stored in the object's meta hash, and look like this:
+
+      // Object's meta hash
+      {
+        listeners: {       // variable name: `listenerSet`
+          "foo:change": [ // variable name: `actions`
+            target, method, once
+          ]
+        }
+      }
+
+*/
+
+/**
+  Add an event listener
+
+  @method addListener
+  @static
+  @for @ember/object/events
+  @param obj
+  @param {String} eventName
+  @param {Object|Function} target A target object or a function
+  @param {Function|String} method A function or the name of a function to be called on `target`
+  @param {Boolean} once A flag whether a function should only be called once
+  @public
+*/
+function addListener(obj, eventName, target, method, once, sync = true) {
+  (!(Boolean(obj) && Boolean(eventName)) && assert('You must pass at least an object and event name to addListener', Boolean(obj) && Boolean(eventName)));
+  if (!method && 'function' === typeof target) {
+    method = target;
+    target = null;
+  }
+  meta(obj).addToListeners(eventName, target, method, once === true, sync);
+}
+
+/**
+  Remove an event listener
+
+  Arguments should match those passed to `addListener`.
+
+  @method removeListener
+  @static
+  @for @ember/object/events
+  @param obj
+  @param {String} eventName
+  @param {Object|Function} target A target object or a function
+  @param {Function|String} method A function or the name of a function to be called on `target`
+  @public
+*/
+function removeListener(obj, eventName, targetOrFunction, functionOrName) {
+  (!(Boolean(obj) && Boolean(eventName) && (typeof targetOrFunction === 'function' || typeof targetOrFunction === 'object' && Boolean(functionOrName))) && assert('You must pass at least an object, event name, and method or target and method/method name to removeListener', Boolean(obj) && Boolean(eventName) && (typeof targetOrFunction === 'function' || typeof targetOrFunction === 'object' && Boolean(functionOrName))));
+  let target, method;
+  if (typeof targetOrFunction === 'object') {
+    target = targetOrFunction;
+    method = functionOrName;
+  } else {
+    target = null;
+    method = targetOrFunction;
+  }
+  let m = meta(obj);
+  m.removeFromListeners(eventName, target, method);
+}
+
+/**
+  Send an event. The execution of suspended listeners
+  is skipped, and once listeners are removed. A listener without
+  a target is executed on the passed object. If an array of actions
+  is not passed, the actions stored on the passed object are invoked.
+
+  @method sendEvent
+  @static
+  @for @ember/object/events
+  @param obj
+  @param {String} eventName
+  @param {Array} params Optional parameters for each listener.
+  @return {Boolean} if the event was delivered to one or more actions
+  @public
+*/
+function sendEvent(obj, eventName, params, actions, _meta) {
+  if (actions === undefined) {
+    let meta = _meta === undefined ? peekMeta(obj) : _meta;
+    actions = meta !== null ? meta.matchingListeners(eventName) : undefined;
+  }
+  if (actions === undefined || actions.length === 0) {
+    return false;
+  }
+  for (let i = actions.length - 3; i >= 0; i -= 3) {
+    // looping in reverse for once listeners
+    let target = actions[i];
+    let method = actions[i + 1];
+    let once = actions[i + 2];
+    if (!method) {
+      continue;
+    }
+    if (once) {
+      removeListener(obj, eventName, target, method);
+    }
+    if (!target) {
+      target = obj;
+    }
+    let type = typeof method;
+    if (type === 'string' || type === 'symbol') {
+      method = target[method];
+    }
+    method.apply(target, params);
+  }
+  return true;
+}
+
+/**
+  @public
+  @method hasListeners
+  @static
+  @for @ember/object/events
+  @param obj
+  @param {String} eventName
+  @return {Boolean} if `obj` has listeners for event `eventName`
+*/
+function hasListeners(obj, eventName) {
+  let meta = peekMeta(obj);
+  if (meta === null) {
+    return false;
+  }
+  let matched = meta.matchingListeners(eventName);
+  return matched !== undefined && matched.length > 0;
+}
+
+/**
+  Define a property as a function that should be executed when
+  a specified event or events are triggered.
+
+  ``` javascript
+  import EmberObject from '@ember/object';
+  import { on } from '@ember/object/evented';
+  import { sendEvent } from '@ember/object/events';
+
+  let Job = EmberObject.extend({
+    logCompleted: on('completed', function() {
+      console.log('Job completed!');
+    })
+  });
+
+  let job = Job.create();
+
+  sendEvent(job, 'completed'); // Logs 'Job completed!'
+ ```
+
+  @method on
+  @static
+  @for @ember/object/evented
+  @param {String} eventNames*
+  @param {Function} func
+  @return {Function} the listener function, passed as last argument to on(...)
+  @public
+*/
+function on(...args) {
+  let func = args.pop();
+  let events = args;
+  (!(typeof func === 'function') && assert('on expects function as last argument', typeof func === 'function'));
+  (!(events.length > 0 && events.every(p => typeof p === 'string' && p.length > 0)) && assert('on called without valid event names', events.length > 0 && events.every(p => typeof p === 'string' && p.length > 0)));
+  setListeners(func, events);
+  return func;
+}
+
+export { addListener as a, hasListeners as h, on as o, removeListener as r, sendEvent as s };

package/dist/dev/packages/shared-chunks/get-CpJjYeJO.js

@@ -0,0 +1,138 @@
+import { a as createComputeRef, U as UNDEFINED_REFERENCE, v as valueForRef } from './reference-BoPB2LfI.js';
+import { f as reifyPositional } from './untouchable-this-cH6_N2LJ.js';
+import { i as internalHelper } from './hash-D3BENmhU.js';
+import { setPath, getPath } from '../@glimmer/global-context/index.js';
+import { i as isDict } from './collections-DPkjqeA3.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/dev/packages/shared-chunks/get-debug-name-CSniHBsn.js

@@ -0,0 +1,45 @@
+let getDebugName;
+{
+  let getFunctionName = fn => {
+    let functionName = fn.name;
+    if (functionName === undefined) {
+      let match = Function.prototype.toString.call(fn).match(/function (\w+)\s*\(/);
+      functionName = match && match[1] || '';
+    }
+    return functionName.replace(/^bound /, '');
+  };
+  let getObjectName = obj => {
+    let name;
+    let className;
+    if (obj.constructor && obj.constructor !== Object) {
+      className = getFunctionName(obj.constructor);
+    }
+    if ('toString' in obj && obj.toString !== Object.prototype.toString && obj.toString !== Function.prototype.toString) {
+      name = obj.toString();
+    }
+
+    // If the class has a decent looking name, and the `toString` is one of the
+    // default Ember toStrings, replace the constructor portion of the toString
+    // with the class name. We check the length of the class name to prevent doing
+    // this when the value is minified.
+    if (name && name.match(/<.*:ember\d+>/) && className && className[0] !== '_' && className.length > 2 && className !== 'Class') {
+      return name.replace(/<.*:/, `<${className}:`);
+    }
+    return name || className;
+  };
+  let getPrimitiveName = value => {
+    return String(value);
+  };
+  getDebugName = value => {
+    if (typeof value === 'function') {
+      return getFunctionName(value) || `(unknown function)`;
+    } else if (typeof value === 'object' && value !== null) {
+      return getObjectName(value) || `(unknown object)`;
+    } else {
+      return getPrimitiveName(value);
+    }
+  };
+}
+const getDebugName$1 = getDebugName;
+
+export { getDebugName$1 as g };

package/dist/dev/packages/shared-chunks/get_properties-CIm8IAtP.js

@@ -0,0 +1,55 @@
+import { g as get } from './property_get-CIBS9umw.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/dev/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 };