ember-source 5.11.0-beta.2 → 5.11.1

package/dist/packages/@ember/component/helper.js

@@ -1,9 +1,9 @@
 import '../../@glimmer/opcode-compiler/index.js';
-export { H as default, h as helper } from '../../shared-chunks/index-BXPoca1S.js';
-import '../../shared-chunks/registry-DzfcDwii.js';
-import '../../shared-chunks/index-DTxy4Zgx.js';
+export { H as default, h as helper } from '../../shared-chunks/index-Llq6dmgX.js';
+import '../../shared-chunks/registry-B8WARvkP.js';
+import '../debug/index.js';
 import '../../@glimmer/runtime/index.js';
-import '../../shared-chunks/cache-gDE3bkXq.js';
+import '../runloop/index.js';
 import '../../@glimmer/reference/index.js';
 import '../../@glimmer/validator/index.js';
 import '@embroider/macros';

package/dist/packages/@ember/component/index.js

@@ -1,10 +1,10 @@
 export { componentCapabilities as capabilities, getComponentTemplate, setComponentTemplate } from '../../@glimmer/manager/index.js';
 import '../../@glimmer/opcode-compiler/index.js';
-export { I as Input, T as Textarea, C as default } from '../../shared-chunks/index-BXPoca1S.js';
-import '../../shared-chunks/registry-DzfcDwii.js';
-import '../../shared-chunks/index-DTxy4Zgx.js';
+export { I as Input, T as Textarea, C as default } from '../../shared-chunks/index-Llq6dmgX.js';
+import '../../shared-chunks/registry-B8WARvkP.js';
+import '../debug/index.js';
 import '../../@glimmer/runtime/index.js';
-import '../../shared-chunks/cache-gDE3bkXq.js';
+import '../runloop/index.js';
 import '../../@glimmer/reference/index.js';
 import '../../@glimmer/validator/index.js';
 import '@embroider/macros';

package/dist/packages/@ember/controller/index.js

@@ -1,15 +1,15 @@
 import { getOwner } from '../-internals/owner/index.js';
-import '../../shared-chunks/index-PYiGj1jp.js';
+import '../object/index.js';
 import { FrameworkObject } from '../object/-internals.js';
-import { c as computed, g as get, f as inject$1 } from '../../shared-chunks/cache-gDE3bkXq.js';
+import { c as computed, g as get, p as inject$1 } from '../../shared-chunks/cache-BESCGvbE.js';
 import '../-internals/meta/lib/meta.js';
-import '../../shared-chunks/index-DTxy4Zgx.js';
+import '../debug/index.js';
 import '../../@glimmer/validator/index.js';
-import { s as symbol } from '../../shared-chunks/to-string-D8i3mjEU.js';
-import '../../shared-chunks/mandatory-setter-1UQhiJOb.js';
-import '@embroider/macros';
+import { s as symbol } from '../../shared-chunks/to-string-B1BmwUkt.js';
+import '../../shared-chunks/mandatory-setter-BiXq-dpN.js';
 import '../../@glimmer/destroyable/index.js';
 import '../../@glimmer/manager/index.js';
+import '@embroider/macros';
 import '../../shared-chunks/env-BJLX2Arx.js';
 import Mixin from '../object/mixin.js';
 import '../-internals/runtime/lib/mixins/registry_proxy.js';

package/dist/packages/@ember/debug/container-debug-adapter.js

@@ -1,14 +1,15 @@
 import { classify, dasherize } from '../-internals/string/index.js';
-import { E as EmberObject, t as typeOf } from '../../shared-chunks/index-PYiGj1jp.js';
+import EmberObject from '../object/index.js';
 import '../-internals/meta/lib/meta.js';
-import '../../shared-chunks/mandatory-setter-1UQhiJOb.js';
+import '../../shared-chunks/mandatory-setter-BiXq-dpN.js';
 import '@embroider/macros';
-import '../../shared-chunks/index-DTxy4Zgx.js';
+import './index.js';
 import '../../@glimmer/destroyable/index.js';
 import '../../@glimmer/validator/index.js';
-import '../../shared-chunks/cache-gDE3bkXq.js';
 import '../../@glimmer/manager/index.js';
+import '../../shared-chunks/cache-BESCGvbE.js';
 import '../../shared-chunks/env-BJLX2Arx.js';
+import typeOf from '../utils/lib/type-of.js';
 import '../-internals/runtime/lib/mixins/registry_proxy.js';
 import '../-internals/runtime/lib/mixins/container_proxy.js';
 import '../-internals/runtime/lib/mixins/comparable.js';

package/dist/packages/@ember/debug/data-adapter.js

@@ -1,16 +1,19 @@
 import { getOwner } from '../-internals/owner/index.js';
-import { _ as _backburner, g as get, X as next } from '../../shared-chunks/cache-gDE3bkXq.js';
-import { E as EmberObject, A } from '../../shared-chunks/index-PYiGj1jp.js';
+import { _backburner, next } from '../runloop/index.js';
+import EmberObject from '../object/index.js';
 import { dasherize } from '../-internals/string/index.js';
 import Namespace from '../application/namespace.js';
+import { A } from '../array/index.js';
 import { createCache, consumeTag, tagFor, untrack, getValue } from '../../@glimmer/validator/index.js';
-import { a as assert } from '../../shared-chunks/index-DTxy4Zgx.js';
+import './index.js';
+import { g as get } from '../../shared-chunks/cache-BESCGvbE.js';
 import '../-internals/meta/lib/meta.js';
-import '../../shared-chunks/mandatory-setter-1UQhiJOb.js';
+import '../../shared-chunks/mandatory-setter-BiXq-dpN.js';
 import '@embroider/macros';
 import '../../@glimmer/destroyable/index.js';
 import '../../@glimmer/manager/index.js';
 import '../../shared-chunks/env-BJLX2Arx.js';
+import { assert } from './lib/assert.js';
 
 /**
 @module @ember/debug/data-adapter

package/dist/packages/@ember/debug/index.js

@@ -1,5 +1,214 @@
-import '../../shared-chunks/index-BGP1rw3B.js';
-export { t as _warnIfUsingStrippedFeatureFlags, a as assert, c as debug, h as debugFreeze, p as debugSeal, d as deprecate, e as deprecateFunc, q as getDebugFunction, i as info, b as inspect, f as registerDeprecationHandler, g as registerWarnHandler, r as runInDebug, s as setDebugFunction, w as warn } from '../../shared-chunks/index-DTxy4Zgx.js';
-export { isTesting, setTesting } from './lib/testing.js';
-import '@embroider/macros';
+import { i as isFirefox, a as isChrome } from '../../shared-chunks/index-BGP1rw3B.js';
+import _deprecate from './lib/deprecate.js';
+export { registerHandler as registerDeprecationHandler } from './lib/deprecate.js';
+import { isTesting } from './lib/testing.js';
+export { setTesting } from './lib/testing.js';
+import _warn from './lib/warn.js';
+export { registerHandler as registerWarnHandler } from './lib/warn.js';
+import { setAssert, assert } from './lib/assert.js';
+import { isDevelopingApp } from '@embroider/macros';
+export { default as inspect } from './lib/inspect.js';
 export { default as captureRenderTree } from './lib/capture-render-tree.js';
+
+// These are the default production build versions:
+const noop = () => {};
+
+// SAFETY: these casts are just straight-up lies, but the point is that they do
+// not do anything in production builds.
+let info = noop;
+let warn = noop;
+let debug = noop;
+let deprecate = noop;
+let debugSeal = noop;
+let debugFreeze = noop;
+let runInDebug = noop;
+let setDebugFunction = noop;
+let getDebugFunction = noop;
+let deprecateFunc = function () {
+  return arguments[arguments.length - 1];
+};
+if (isDevelopingApp()) {
+  setDebugFunction = function (type, callback) {
+    switch (type) {
+      case 'assert':
+        return setAssert(callback);
+      case 'info':
+        return info = callback;
+      case 'warn':
+        return warn = callback;
+      case 'debug':
+        return debug = callback;
+      case 'deprecate':
+        return deprecate = callback;
+      case 'debugSeal':
+        return debugSeal = callback;
+      case 'debugFreeze':
+        return debugFreeze = callback;
+      case 'runInDebug':
+        return runInDebug = callback;
+      case 'deprecateFunc':
+        return deprecateFunc = callback;
+    }
+  };
+  getDebugFunction = function (type) {
+    switch (type) {
+      case 'assert':
+        return assert;
+      case 'info':
+        return info;
+      case 'warn':
+        return warn;
+      case 'debug':
+        return debug;
+      case 'deprecate':
+        return deprecate;
+      case 'debugSeal':
+        return debugSeal;
+      case 'debugFreeze':
+        return debugFreeze;
+      case 'runInDebug':
+        return runInDebug;
+      case 'deprecateFunc':
+        return deprecateFunc;
+    }
+  };
+}
+
+/**
+@module @ember/debug
+*/
+
+if (isDevelopingApp()) {
+  /**
+    Display a debug notice.
+     Calls to this function are not invoked in production builds.
+     ```javascript
+    import { debug } from '@ember/debug';
+     debug('I\'m a debug notice!');
+    ```
+     @method debug
+    @for @ember/debug
+    @static
+    @param {String} message A debug message to display.
+    @public
+  */
+  setDebugFunction('debug', function debug(message) {
+    console.debug(`DEBUG: ${message}`); /* eslint-disable-line no-console */
+  });
+
+  /**
+    Display an info notice.
+     Calls to this function are removed from production builds, so they can be
+    freely added for documentation and debugging purposes without worries of
+    incuring any performance penalty.
+     @method info
+    @private
+  */
+  setDebugFunction('info', function info() {
+    console.info(...arguments); /* eslint-disable-line no-console */
+  });
+
+  /**
+   @module @ember/debug
+   @public
+  */
+
+  /**
+    Alias an old, deprecated method with its new counterpart.
+     Display a deprecation warning with the provided message and a stack trace
+    (Chrome and Firefox only) when the assigned method is called.
+     Calls to this function are removed from production builds, so they can be
+    freely added for documentation and debugging purposes without worries of
+    incuring any performance penalty.
+     ```javascript
+    import { deprecateFunc } from '@ember/debug';
+     Ember.oldMethod = deprecateFunc('Please use the new, updated method', options, Ember.newMethod);
+    ```
+     @method deprecateFunc
+    @static
+    @for @ember/debug
+    @param {String} message A description of the deprecation.
+    @param {Object} [options] The options object for `deprecate`.
+    @param {Function} func The new function called to replace its deprecated counterpart.
+    @return {Function} A new function that wraps the original function with a deprecation warning
+    @private
+  */
+  setDebugFunction('deprecateFunc', function deprecateFunc(...args) {
+    if (args.length === 3) {
+      let [message, options, func] = args;
+      return function (...args) {
+        deprecate(message, false, options);
+        return func.apply(this, args);
+      };
+    } else {
+      let [message, func] = args;
+      return function () {
+        deprecate(message);
+        return func.apply(this, arguments);
+      };
+    }
+  });
+
+  /**
+   @module @ember/debug
+   @public
+  */
+  /**
+    Run a function meant for debugging.
+     Calls to this function are removed from production builds, so they can be
+    freely added for documentation and debugging purposes without worries of
+    incuring any performance penalty.
+     ```javascript
+    import Component from '@ember/component';
+    import { runInDebug } from '@ember/debug';
+     runInDebug(() => {
+      Component.reopen({
+        didInsertElement() {
+          console.log("I'm happy");
+        }
+      });
+    });
+    ```
+     @method runInDebug
+    @for @ember/debug
+    @static
+    @param {Function} func The function to be executed.
+    @since 1.5.0
+    @public
+  */
+  setDebugFunction('runInDebug', function runInDebug(func) {
+    func();
+  });
+  setDebugFunction('debugSeal', function debugSeal(obj) {
+    Object.seal(obj);
+  });
+  setDebugFunction('debugFreeze', function debugFreeze(obj) {
+    // re-freezing an already frozen object introduces a significant
+    // performance penalty on Chrome (tested through 59).
+    //
+    // See: https://bugs.chromium.org/p/v8/issues/detail?id=6450
+    if (!Object.isFrozen(obj)) {
+      Object.freeze(obj);
+    }
+  });
+  setDebugFunction('deprecate', _deprecate);
+  setDebugFunction('warn', _warn);
+}
+let _warnIfUsingStrippedFeatureFlags;
+if (isDevelopingApp() && !isTesting()) {
+  if (typeof window !== 'undefined' && (isFirefox || isChrome) && window.addEventListener) {
+    window.addEventListener('load', () => {
+      if (document.documentElement && document.documentElement.dataset && !document.documentElement.dataset['emberExtension']) {
+        let downloadURL;
+        if (isChrome) {
+          downloadURL = 'https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi';
+        } else if (isFirefox) {
+          downloadURL = 'https://addons.mozilla.org/en-US/firefox/addon/ember-inspector/';
+        }
+        debug(`For more advanced debugging, install the Ember Inspector from ${downloadURL}`);
+      }
+    }, false);
+  }
+}
+
+export { _warnIfUsingStrippedFeatureFlags, assert, debug, debugFreeze, debugSeal, deprecate, deprecateFunc, getDebugFunction, info, isTesting, runInDebug, setDebugFunction, warn };

package/dist/packages/@ember/debug/lib/assert.js

@@ -0,0 +1,47 @@
+import { isDevelopingApp } from '@embroider/macros';
+
+let assert = () => {};
+function setAssert(implementation) {
+  assert = implementation;
+  return implementation;
+}
+if (isDevelopingApp()) {
+  /**
+     Verify that a certain expectation is met, or throw a exception otherwise.
+     This is useful for communicating assumptions in the code to other human
+     readers as well as catching bugs that accidentally violates these
+     expectations.
+     Assertions are removed from production builds, so they can be freely added
+     for documentation and debugging purposes without worries of incuring any
+     performance penalty. However, because of that, they should not be used for
+     checks that could reasonably fail during normal usage. Furthermore, care
+     should be taken to avoid accidentally relying on side-effects produced from
+     evaluating the condition itself, since the code will not run in production.
+     ```javascript
+     import { assert } from '@ember/debug';
+     // Test for truthiness
+     assert('Must pass a string', typeof str === 'string');
+     // Fail unconditionally
+     assert('This code path should never be run');
+     ```
+     @method assert
+     @static
+     @for @ember/debug
+     @param {String} description Describes the expectation. This will become the
+       text of the Error thrown if the assertion fails.
+     @param {any} condition Must be truthy for the assertion to pass. If
+       falsy, an exception will be thrown.
+     @public
+     @since 1.0.0
+   */
+
+  // eslint-disable-next-line no-inner-declarations
+  function assert(desc, test) {
+    if (!test) {
+      throw new Error(`Assertion Failed: ${desc}`);
+    }
+  }
+  setAssert(assert);
+}
+
+export { assert, setAssert };

package/dist/packages/@ember/debug/lib/deprecate.js

@@ -1,4 +1,194 @@
-import '../../../shared-chunks/env-BJLX2Arx.js';
-export { _ as default, k as missingOptionDeprecation, m as missingOptionsDeprecation, j as missingOptionsIdDeprecation, f as registerHandler } from '../../../shared-chunks/index-DTxy4Zgx.js';
-import './handlers.js';
-import '@embroider/macros';
+import { E as ENV } from '../../../shared-chunks/env-BJLX2Arx.js';
+import { assert } from './assert.js';
+import { registerHandler as registerHandler$1, invoke } from './handlers.js';
+import { isDevelopingApp } from '@embroider/macros';
+
+/**
+ @module @ember/debug
+ @public
+*/
+/**
+  Allows for runtime registration of handler functions that override the default deprecation behavior.
+  Deprecations are invoked by calls to [@ember/debug/deprecate](/ember/release/classes/@ember%2Fdebug/methods/deprecate?anchor=deprecate).
+  The following example demonstrates its usage by registering a handler that throws an error if the
+  message contains the word "should", otherwise defers to the default handler.
+
+  ```javascript
+  import { registerDeprecationHandler } from '@ember/debug';
+
+  registerDeprecationHandler((message, options, next) => {
+    if (message.indexOf('should') !== -1) {
+      throw new Error(`Deprecation message with should: ${message}`);
+    } else {
+      // defer to whatever handler was registered before this one
+      next(message, options);
+    }
+  });
+  ```
+
+  The handler function takes the following arguments:
+
+  <ul>
+    <li> <code>message</code> - The message received from the deprecation call.</li>
+    <li> <code>options</code> - An object passed in with the deprecation call containing additional information including:</li>
+      <ul>
+        <li> <code>id</code> - An id of the deprecation in the form of <code>package-name.specific-deprecation</code>.</li>
+        <li> <code>until</code> - The Ember version number the feature and deprecation will be removed in.</li>
+      </ul>
+    <li> <code>next</code> - A function that calls into the previously registered handler.</li>
+  </ul>
+
+  @public
+  @static
+  @method registerDeprecationHandler
+  @for @ember/debug
+  @param handler {Function} A function to handle deprecation calls.
+  @since 2.1.0
+*/
+let registerHandler = () => {};
+let missingOptionsDeprecation;
+let missingOptionsIdDeprecation;
+let missingOptionDeprecation = () => '';
+let deprecate = () => {};
+if (isDevelopingApp()) {
+  registerHandler = function registerHandler(handler) {
+    registerHandler$1('deprecate', handler);
+  };
+  let formatMessage = function formatMessage(_message, options) {
+    let message = _message;
+    if (options?.id) {
+      message = message + ` [deprecation id: ${options.id}]`;
+    }
+    if (options?.until) {
+      message = message + ` This will be removed in ${options.for} ${options.until}.`;
+    }
+    if (options?.url) {
+      message += ` See ${options.url} for more details.`;
+    }
+    return message;
+  };
+  registerHandler(function logDeprecationToConsole(message, options) {
+    let updatedMessage = formatMessage(message, options);
+    console.warn(`DEPRECATION: ${updatedMessage}`); // eslint-disable-line no-console
+  });
+  let captureErrorForStack;
+  if (new Error().stack) {
+    captureErrorForStack = () => new Error();
+  } else {
+    captureErrorForStack = () => {
+      try {
+        __fail__.fail();
+        return;
+      } catch (e) {
+        return e;
+      }
+    };
+  }
+  registerHandler(function logDeprecationStackTrace(message, options, next) {
+    if (ENV.LOG_STACKTRACE_ON_DEPRECATION) {
+      let stackStr = '';
+      let error = captureErrorForStack();
+      let stack;
+      if (error instanceof Error) {
+        if (error.stack) {
+          if (error['arguments']) {
+            // Chrome
+            stack = error.stack.replace(/^\s+at\s+/gm, '').replace(/^([^(]+?)([\n$])/gm, '{anonymous}($1)$2').replace(/^Object.<anonymous>\s*\(([^)]+)\)/gm, '{anonymous}($1)').split('\n');
+            stack.shift();
+          } else {
+            // Firefox
+            stack = error.stack.replace(/(?:\n@:0)?\s+$/m, '').replace(/^\(/gm, '{anonymous}(').split('\n');
+          }
+          stackStr = `\n    ${stack.slice(2).join('\n    ')}`;
+        }
+      }
+      let updatedMessage = formatMessage(message, options);
+      console.warn(`DEPRECATION: ${updatedMessage}${stackStr}`); // eslint-disable-line no-console
+    } else {
+      next(message, options);
+    }
+  });
+  registerHandler(function raiseOnDeprecation(message, options, next) {
+    if (ENV.RAISE_ON_DEPRECATION) {
+      let updatedMessage = formatMessage(message);
+      throw new Error(updatedMessage);
+    } else {
+      next(message, options);
+    }
+  });
+  missingOptionsDeprecation = 'When calling `deprecate` you ' + 'must provide an `options` hash as the third parameter.  ' + '`options` should include `id` and `until` properties.';
+  missingOptionsIdDeprecation = 'When calling `deprecate` you must provide `id` in options.';
+  missingOptionDeprecation = (id, missingOption) => {
+    return `When calling \`deprecate\` you must provide \`${missingOption}\` in options. Missing options.${missingOption} in "${id}" deprecation`;
+  };
+  /**
+   @module @ember/debug
+   @public
+   */
+  /**
+    Display a deprecation warning with the provided message and a stack trace
+    (Chrome and Firefox only).
+     Ember itself leverages [Semantic Versioning](https://semver.org) to aid
+    projects in keeping up with changes to the framework. Before any
+    functionality or API is removed, it first flows linearly through a
+    deprecation staging process. The staging process currently contains two
+    stages: available and enabled.
+     Deprecations are initially released into the 'available' stage.
+    Deprecations will stay in this stage until the replacement API has been
+    marked as a recommended practice via the RFC process and the addon
+    ecosystem has generally adopted the change.
+     Once a deprecation meets the above criteria, it will move into the
+    'enabled' stage where it will remain until the functionality or API is
+    eventually removed.
+     For application and addon developers, "available" deprecations are not
+    urgent and "enabled" deprecations require action.
+     * In a production build, this method is defined as an empty function (NOP).
+    Uses of this method in Ember itself are stripped from the ember.prod.js build.
+     ```javascript
+    import { deprecate } from '@ember/debug';
+     deprecate(
+      'Use of `assign` has been deprecated. Please use `Object.assign` or the spread operator instead.',
+      false,
+      {
+        id: 'ember-polyfills.deprecate-assign',
+        until: '5.0.0',
+        url: 'https://deprecations.emberjs.com/v4.x/#toc_ember-polyfills-deprecate-assign',
+        for: 'ember-source',
+        since: {
+          available: '4.0.0',
+          enabled: '4.0.0',
+        },
+      }
+    );
+    ```
+     @method deprecate
+    @for @ember/debug
+    @param {String} message A description of the deprecation.
+    @param {Boolean} test A boolean. If falsy, the deprecation will be displayed.
+    @param {Object} options
+    @param {String} options.id A unique id for this deprecation. The id can be
+      used by Ember debugging tools to change the behavior (raise, log or silence)
+      for that specific deprecation. The id should be namespaced by dots, e.g.
+      "view.helper.select".
+    @param {string} options.until The version of Ember when this deprecation
+      warning will be removed.
+    @param {String} options.for A namespace for the deprecation, usually the package name
+    @param {Object} options.since Describes when the deprecation became available and enabled.
+    @param {String} [options.url] An optional url to the transition guide on the
+          emberjs.com website.
+    @static
+    @public
+    @since 1.0.0
+  */
+  deprecate = function deprecate(message, test, options) {
+    assert(missingOptionsDeprecation, Boolean(options && (options.id || options.until)));
+    assert(missingOptionsIdDeprecation, Boolean(options.id));
+    assert(missingOptionDeprecation(options.id, 'until'), Boolean(options.until));
+    assert(missingOptionDeprecation(options.id, 'for'), Boolean(options.for));
+    assert(missingOptionDeprecation(options.id, 'since'), Boolean(options.since));
+    invoke('deprecate', message, test, options);
+  };
+}
+const _deprecate = deprecate;
+
+export { _deprecate as default, missingOptionDeprecation, missingOptionsDeprecation, missingOptionsIdDeprecation, registerHandler };