ember-source 6.12.0-beta.3 → 7.0.0-alpha.1

package/dist/prod/packages/@ember/debug/lib/capture-render-tree.js

@@ -0,0 +1,28 @@
+/**
+  @module @ember/debug
+*/
+/**
+  Ember Inspector calls this function to capture the current render tree.
+
+  In production mode, this requires turning on `ENV._DEBUG_RENDER_TREE`
+  before loading Ember.
+
+  @private
+  @static
+  @method captureRenderTree
+  @for @ember/debug
+  @param app {ApplicationInstance} An `ApplicationInstance`.
+  @since 3.14.0
+*/
+function captureRenderTree(app) {
+  let domRenderer = app.lookup('renderer:-dom');
+  if (!domRenderer) {
+    throw new Error(`BUG: owner is missing renderer`);
+  }
+  // SAFETY: Ideally we'd assert here but that causes awkward circular requires since this is also in @ember/debug.
+  // This is only for debug stuff so not very risky.
+  let renderer = domRenderer;
+  return renderer.debugRenderTree.capture();
+}
+
+export { captureRenderTree as default };

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

@@ -0,0 +1,56 @@
+import '../../-internals/environment/index.js';
+
+// This is a "global", but instead of declaring it as `declare global`, which
+// will expose it to all other modules, declare it *locally* (and don't export
+// it) so that it has the desired "private global" semantics -- however odd that
+// particular notion is.
+
+/**
+ @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 = () => {};
+
+export { deprecate as default, missingOptionDeprecation, missingOptionsDeprecation, missingOptionsIdDeprecation, registerHandler };

package/dist/prod/packages/@ember/debug/lib/handlers.js

@@ -0,0 +1,5 @@
+let HANDLERS = {};
+let registerHandler = function registerHandler(_type, _callback) {};
+let invoke = () => {};
+
+export { HANDLERS, invoke, registerHandler };

package/dist/prod/packages/@ember/debug/lib/inspect.js

@@ -0,0 +1,120 @@
+import { assert } from './assert.js';
+
+const {
+  toString: objectToString
+} = Object.prototype;
+const {
+  toString: functionToString
+} = Function.prototype;
+const {
+  isArray
+} = Array;
+const {
+  keys: objectKeys
+} = Object;
+const {
+  stringify
+} = JSON;
+const LIST_LIMIT = 100;
+const DEPTH_LIMIT = 4;
+const SAFE_KEY = /^[\w$]+$/;
+
+/**
+ @module @ember/debug
+*/
+/**
+  Convenience method to inspect an object. This method will attempt to
+  convert the object into a useful string description.
+
+  It is a pretty simple implementation. If you want something more robust,
+  use something like JSDump: https://github.com/NV/jsDump
+
+  @method inspect
+  @static
+  @param {Object} obj The object you want to inspect.
+  @return {String} A description of the object
+  @since 1.4.0
+  @private
+*/
+function inspect(obj) {
+  // detect Node util.inspect call inspect(depth: number, opts: object)
+  if (typeof obj === 'number' && arguments.length === 2) {
+    return this;
+  }
+  return inspectValue(obj, 0);
+}
+function inspectValue(value, depth, seen) {
+  let valueIsArray = false;
+  switch (typeof value) {
+    case 'undefined':
+      return 'undefined';
+    case 'object':
+      if (value === null) return 'null';
+      if (isArray(value)) {
+        valueIsArray = true;
+        break;
+      }
+      // is toString Object.prototype.toString or undefined then traverse
+      if (value.toString === objectToString || value.toString === undefined) {
+        break;
+      }
+      // custom toString
+      return value.toString();
+    case 'function':
+      return value.toString === functionToString ? value.name ? `[Function:${value.name}]` : `[Function]` : value.toString();
+    case 'string':
+      return stringify(value);
+    case 'symbol':
+    case 'boolean':
+    case 'number':
+    default:
+      return value.toString();
+  }
+  if (seen === undefined) {
+    seen = new WeakSet();
+  } else {
+    if (seen.has(value)) return `[Circular]`;
+  }
+  seen.add(value);
+  return valueIsArray ? inspectArray(value, depth + 1, seen) : inspectObject(value, depth + 1, seen);
+}
+function inspectKey(key) {
+  return SAFE_KEY.test(key) ? key : stringify(key);
+}
+function inspectObject(obj, depth, seen) {
+  if (depth > DEPTH_LIMIT) {
+    return '[Object]';
+  }
+  let s = '{';
+  let keys = objectKeys(obj);
+  for (let i = 0; i < keys.length; i++) {
+    s += i === 0 ? ' ' : ', ';
+    if (i >= LIST_LIMIT) {
+      s += `... ${keys.length - LIST_LIMIT} more keys`;
+      break;
+    }
+    let key = keys[i];
+    assert('has key', key); // Looping over array
+    s += `${inspectKey(String(key))}: ${inspectValue(obj[key], depth, seen)}`;
+  }
+  s += ' }';
+  return s;
+}
+function inspectArray(arr, depth, seen) {
+  if (depth > DEPTH_LIMIT) {
+    return '[Array]';
+  }
+  let s = '[';
+  for (let i = 0; i < arr.length; i++) {
+    s += i === 0 ? ' ' : ', ';
+    if (i >= LIST_LIMIT) {
+      s += `... ${arr.length - LIST_LIMIT} more items`;
+      break;
+    }
+    s += inspectValue(arr[i], depth, seen);
+  }
+  s += ' ]';
+  return s;
+}
+
+export { inspect as default };

package/dist/prod/packages/@ember/debug/lib/testing.js

@@ -0,0 +1,9 @@
+let testing = false;
+function isTesting() {
+  return testing;
+}
+function setTesting(value) {
+  testing = Boolean(value);
+}
+
+export { isTesting, setTesting };

package/dist/prod/packages/@ember/debug/lib/warn.js

@@ -0,0 +1,6 @@
+let registerHandler = () => {};
+let warn = () => {};
+let missingOptionsDeprecation;
+let missingOptionsIdDeprecation;
+
+export { warn as default, missingOptionsDeprecation, missingOptionsIdDeprecation, registerHandler };

package/dist/prod/packages/@ember/deprecated-features/index.js

@@ -0,0 +1,7 @@
+// These versions should be the version that the deprecation was _introduced_,
+// not the version that the feature will be removed.
+
+/** Introduced in 4.0.0-beta.1 */
+const ASSIGN = true;
+
+export { ASSIGN };

package/dist/prod/packages/@ember/destroyable/index.js

@@ -0,0 +1,251 @@
+import { registerDestructor as registerDestructor$1, unregisterDestructor as unregisterDestructor$1 } from '../../@glimmer/destroyable/index.js';
+export { assertDestroyablesDestroyed, associateDestroyableChild, destroy, enableDestroyableTracking, isDestroyed, isDestroying } from '../../@glimmer/destroyable/index.js';
+
+/**
+  Ember manages the lifecycles and lifetimes of many built in constructs, such
+  as components, and does so in a hierarchical way - when a parent component is
+  destroyed, all of its children are destroyed as well.
+
+  This destroyables API exposes the basic building blocks for destruction:
+
+  * registering a function to be ran when an object is destroyed
+  * checking if an object is in a destroying state
+  * associate an object as a child of another so that the child object will be destroyed
+    when the associated parent object is destroyed.
+
+  @module @ember/destroyable
+  @public
+*/
+
+/**
+  This function is used to associate a destroyable object with a parent. When the parent
+  is destroyed, all registered children will also be destroyed.
+
+  ```js
+  class CustomSelect extends Component {
+    constructor(...args) {
+      super(...args);
+
+      // obj is now a child of the component. When the component is destroyed,
+      // obj will also be destroyed, and have all of its destructors triggered.
+      this.obj = associateDestroyableChild(this, {});
+    }
+  }
+  ```
+
+  Returns the associated child for convenience.
+
+  @method associateDestroyableChild
+  @for @ember/destroyable
+  @param {Object|Function} parent the destroyable to entangle the child destroyables lifetime with
+  @param {Object|Function} child the destroyable to be entangled with the parents lifetime
+  @returns {Object|Function} the child argument
+  @static
+  @public
+*/
+
+/**
+ Receives a destroyable, and returns true if the destroyable has begun destroying. Otherwise returns
+ false.
+
+  ```js
+  let obj = {};
+  isDestroying(obj); // false
+  destroy(obj);
+  isDestroying(obj); // true
+  // ...sometime later, after scheduled destruction
+  isDestroyed(obj); // true
+  isDestroying(obj); // true
+  ```
+
+  @method isDestroying
+  @for @ember/destroyable
+  @param {Object|Function} destroyable the object to check
+  @returns {Boolean}
+  @static
+  @public
+*/
+
+/**
+  Receives a destroyable, and returns true if the destroyable has finished destroying. Otherwise
+  returns false.
+
+  ```js
+  let obj = {};
+
+  isDestroyed(obj); // false
+  destroy(obj);
+
+  // ...sometime later, after scheduled destruction
+
+  isDestroyed(obj); // true
+  ```
+
+  @method isDestroyed
+  @for @ember/destroyable
+  @param {Object|Function} destroyable the object to check
+  @returns {Boolean}
+  @static
+  @public
+*/
+
+/**
+  Initiates the destruction of a destroyable object. It runs all associated destructors, and then
+  destroys all children recursively.
+
+  ```js
+  let obj = {};
+
+  registerDestructor(obj, () => console.log('destroyed!'));
+
+  destroy(obj); // this will schedule the destructor to be called
+
+  // ...some time later, during scheduled destruction
+
+  // destroyed!
+  ```
+
+  Destruction via `destroy()` follows these steps:
+
+  1, Mark the destroyable such that `isDestroying(destroyable)` returns `true`
+  2, Call `destroy()` on each of the destroyable's associated children
+  3, Schedule calling the destroyable's destructors
+  4, Schedule setting destroyable such that `isDestroyed(destroyable)` returns `true`
+
+  This results in the entire tree of destroyables being first marked as destroying,
+  then having all of their destructors called, and finally all being marked as isDestroyed.
+  There won't be any in between states where some items are marked as `isDestroying` while
+  destroying, while others are not.
+
+  @method destroy
+  @for @ember/destroyable
+  @param {Object|Function} destroyable the object to destroy
+  @static
+  @public
+*/
+
+/**
+  This function asserts that all objects which have associated destructors or associated children
+  have been destroyed at the time it is called. It is meant to be a low level hook that testing
+  frameworks can use to hook into and validate that all destroyables have in fact been destroyed.
+
+  This function requires that `enableDestroyableTracking` was called previously, and is only
+  available in non-production builds.
+
+  @method assertDestroyablesDestroyed
+  @for @ember/destroyable
+  @static
+  @public
+*/
+
+/**
+  This function instructs the destroyable system to keep track of all destroyables (their
+  children, destructors, etc). This enables a future usage of `assertDestroyablesDestroyed`
+  to be used to ensure that all destroyable tasks (registered destructors and associated children)
+  have completed when `assertDestroyablesDestroyed` is called.
+
+  @method enableDestroyableTracking
+  @for @ember/destroyable
+  @static
+  @public
+*/
+
+/**
+  Receives a destroyable object and a destructor function, and associates the
+  function with it. When the destroyable is destroyed with destroy, or when its
+  parent is destroyed, the destructor function will be called.
+
+  ```js
+  import Component from '@glimmer/component';
+  import { registerDestructor } from '@ember/destroyable';
+
+  class Modal extends Component {
+    @service resize;
+
+    constructor(...args) {
+      super(...args);
+
+      this.resize.register(this, this.layout);
+
+      registerDestructor(this, () => this.resize.unregister(this));
+    }
+  }
+  ```
+
+  Multiple destructors can be associated with a given destroyable, and they can be
+  associated over time, allowing libraries to dynamically add destructors as needed.
+  `registerDestructor` also returns the associated destructor function, for convenience.
+
+  The destructor function is passed a single argument, which is the destroyable itself.
+  This allows the function to be reused multiple times for many destroyables, rather
+  than creating a closure function per destroyable.
+
+  ```js
+  import Component from '@glimmer/component';
+  import { registerDestructor } from '@ember/destroyable';
+
+  function unregisterResize(instance) {
+    instance.resize.unregister(instance);
+  }
+
+  class Modal extends Component {
+    @service resize;
+
+    constructor(...args) {
+      super(...args);
+
+      this.resize.register(this, this.layout);
+
+      registerDestructor(this, unregisterResize);
+    }
+  }
+  ```
+
+  @method registerDestructor
+  @for @ember/destroyable
+  @param {Object|Function} destroyable the destroyable to register the destructor function with
+  @param {Function} destructor the destructor to run when the destroyable object is destroyed
+  @static
+  @public
+*/
+function registerDestructor(destroyable, destructor) {
+  return registerDestructor$1(destroyable, destructor);
+}
+
+/**
+  Receives a destroyable and a destructor function, and de-associates the destructor
+  from the destroyable.
+
+  ```js
+  import Component from '@glimmer/component';
+  import { registerDestructor, unregisterDestructor } from '@ember/destroyable';
+
+  class Modal extends Component {
+    @service modals;
+
+    constructor(...args) {
+      super(...args);
+
+      this.modals.add(this);
+
+      this.modalDestructor = registerDestructor(this, () => this.modals.remove(this));
+    }
+
+    @action pinModal() {
+      unregisterDestructor(this, this.modalDestructor);
+    }
+  }
+  ```
+
+  @method unregisterDestructor
+  @for @ember/destroyable
+  @param {Object|Function} destroyable the destroyable to unregister the destructor function from
+  @param {Function} destructor the destructor to remove from the destroyable
+  @static
+  @public
+*/
+function unregisterDestructor(destroyable, destructor) {
+  return unregisterDestructor$1(destroyable, destructor);
+}
+
+export { registerDestructor, unregisterDestructor };