ember-source 4.10.0-beta.2 → 4.11.0-alpha.2

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

@@ -0,0 +1,117 @@
+import { _WeakSet as WeakSet } from '@glimmer/util';
+import { assert } from '@ember/debug';
+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
+*/
+export default 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;
+}

package/dist/packages/@ember/engine/instance.js

@@ -4,7 +4,6 @@
 import EmberObject from '@ember/object';
 import { RSVP } from '@ember/-internals/runtime';
 import { assert } from '@ember/debug';
-import EmberError from '@ember/error';
 import { Registry, privatize as P } from '@ember/-internals/container';
 import { guidFor } from '@ember/-internals/utils';
 import { ENGINE_PARENT, getEngineParent, setEngineParent } from './lib/engine-parent';
@@ -117,7 +116,7 @@ class EngineInstance extends EmberObject.extend(RegistryProxyMixin, ContainerPro
   buildChildEngineInstance(name, options = {}) {
     let Engine = this.lookup(`engine:${name}`);
     if (!Engine) {
-      throw new EmberError(`You attempted to mount the engine '${name}', but it is not registered with its parent.`);
+      throw new Error(`You attempted to mount the engine '${name}', but it is not registered with its parent.`);
     }
     assert('expected an Engine', Engine instanceof CEngine);
     let engineInstance = Engine.buildInstance(options);

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

@@ -101,15 +101,9 @@ export function instrument(name, p1, p2, p3) {
     return withFinalizer(callback, finalizer, payload, binding);
   }
 }
-let flaggedInstrument;
-if (false /* EMBER_IMPROVED_INSTRUMENTATION */) {
-  flaggedInstrument = instrument;
-} else {
-  flaggedInstrument = function instrument(_name, _payload, callback) {
-    return callback();
-  };
+export function flaggedInstrument(_name, _payload, callback) {
+  return callback();
 }
-export { flaggedInstrument };
 function withFinalizer(callback, finalizer, payload, binding) {
   try {
     return callback.call(binding);

package/dist/packages/@ember/object/core.js

@@ -3,11 +3,12 @@
 */
 import { getFactoryFor, setFactoryFor } from '@ember/-internals/container';
 import { getOwner } from '@ember/-internals/owner';
-import { guidFor, makeArray, isInternalSymbol } from '@ember/-internals/utils';
+import { guidFor, isInternalSymbol } from '@ember/-internals/utils';
 import { meta } from '@ember/-internals/meta';
 import { PROXY_CONTENT, sendEvent, activateObserver, defineProperty, descriptorForProperty, isClassicDecorator, DEBUG_INJECTION_FUNCTIONS, hasUnknownProperty } from '@ember/-internals/metal';
 import Mixin, { applyMixin } from '@ember/object/mixin';
 import { ActionHandler } from '@ember/-internals/runtime';
+import { makeArray } from '@ember/array';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import { _WeakSet as WeakSet } from '@glimmer/util';

package/dist/packages/@ember/object/mixin.js

@@ -3,7 +3,7 @@
 */
 import { INIT_FACTORY } from '@ember/-internals/container';
 import { meta as metaFor, peekMeta } from '@ember/-internals/meta';
-import { guidFor, makeArray, observerListenerMetaFor, ROOT, wrap } from '@ember/-internals/utils';
+import { guidFor, observerListenerMetaFor, ROOT, wrap } from '@ember/-internals/utils';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import { _WeakSet } from '@glimmer/util';
@@ -101,9 +101,18 @@ function giveMethodSuper(key, method, values, descs) {
   }
   return method;
 }
+function simpleMakeArray(value) {
+  if (!value) {
+    return [];
+  } else if (!Array.isArray(value)) {
+    return [value];
+  } else {
+    return value;
+  }
+}
 function applyConcatenatedProperties(key, value, values) {
   let baseValue = values[key];
-  let ret = makeArray(baseValue).concat(makeArray(value));
+  let ret = simpleMakeArray(baseValue).concat(simpleMakeArray(value));
   if (DEBUG) {
     // it is possible to use concatenatedProperties with strings (which cannot be frozen)
     // only freeze objects...

package/dist/packages/@ember/object/promise-proxy-mixin.js

@@ -1,6 +1,5 @@
 import { get, setProperties, computed } from '@ember/object';
 import Mixin from '@ember/object/mixin';
-import EmberError from '@ember/error';
 /**
   @module @ember/object/promise-proxy-mixin
 */
@@ -39,7 +38,7 @@ const PromiseProxyMixin = Mixin.create({
   isFulfilled: false,
   promise: computed({
     get() {
-      throw new EmberError("PromiseProxy's promise must be set");
+      throw new Error("PromiseProxy's promise must be set");
     },
     set(_key, promise) {
       return tap(this, promise);

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

@@ -32,7 +32,7 @@
 // We need to provide a narrower public interface to `getOwner` so that we only
 // expose the `Owner` type, *not* our richer `InternalOwner` type and its
 // various bits of private API.
-import { getOwner as internalGetOwner } from '../-internals/owner';
+import { getOwner as internalGetOwner } from '@ember/-internals/owner';
 // NOTE: this documentation appears here instead of at the definition site so
 // it can appear correctly in both API docs and for TS, while providing a richer
 // internal representation for Ember's own usage.
@@ -84,4 +84,4 @@ import { getOwner as internalGetOwner } from '../-internals/owner';
 // relations to the `DIRegistry`.
 const getOwner = internalGetOwner;
 export { getOwner };
-export { setOwner } from '../-internals/owner';
+export { setOwner } from '@ember/-internals/owner';

package/dist/packages/@ember/routing/lib/utils.js

@@ -2,7 +2,6 @@ import { get } from '@ember/-internals/metal';
 import { getOwner } from '@ember/-internals/owner';
 import { assert, deprecate } from '@ember/debug';
 import EngineInstance from '@ember/engine/instance';
-import EmberError from '@ember/error';
 import { STATE_SYMBOL } from 'router_js';
 const ALL_PERIODS_REGEX = /\./g;
 export function extractRouteArgs(args) {
@@ -184,7 +183,7 @@ export function prefixRouteNameArg(route, args) {
   if (owner.routable && typeof args[0] === 'string') {
     routeName = args[0];
     if (resemblesURL(routeName)) {
-      throw new EmberError('Programmatic transitions by URL cannot be used within an Engine. Please use the route name instead.');
+      throw new Error('Programmatic transitions by URL cannot be used within an Engine. Please use the route name instead.');
     } else {
       routeName = `${prefix}.${routeName}`;
       args[0] = routeName;

package/dist/packages/@ember/routing/router.js

@@ -1,6 +1,6 @@
 import { privatize as P } from '@ember/-internals/container';
 import { computed, get, set } from '@ember/object';
-import { getOwner } from '@ember/-internals/owner';
+import { getOwner } from '@ember/owner';
 import { BucketCache, DSL, RouterState } from '@ember/routing/-internals';
 import { calculateCacheKey, extractRouteArgs, getActiveTargetName, resemblesURL } from './lib/utils';
 import EmberLocation from '@ember/routing/location';
@@ -9,7 +9,6 @@ import { A as emberA } from '@ember/array';
 import { typeOf } from '@ember/utils';
 import Evented from '@ember/object/evented';
 import { assert, deprecate, info } from '@ember/debug';
-import EmberError from '@ember/error';
 import { cancel, once, run, scheduleOnce } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 import { defaultSerialize, getFullQueryParams, hasDefaultSerialize, ROUTE_CONNECTIONS } from '@ember/routing/route';
@@ -67,37 +66,6 @@ const {
   @public
 */
 class EmberRouter extends EmberObject.extend(Evented) {
-  // Note that owner is actually required in this scenario, but since it is strictly
-  // optional in other contexts trying to make it required here confuses TS.
-  constructor(owner) {
-    super(owner);
-    this._didSetupRouter = false;
-    this._initialTransitionStarted = false;
-    this.currentURL = null;
-    this.currentRouteName = null;
-    this.currentPath = null;
-    this.currentRoute = null;
-    this._qpCache = Object.create(null);
-    // Set of QueryParam['urlKey']
-    this._qpUpdates = new Set();
-    this._queuedQPChanges = {};
-    this._toplevelView = null;
-    this._handledErrors = new Set();
-    this._engineInstances = Object.create(null);
-    this._engineInfoByRoute = Object.create(null);
-    this._slowTransitionTimer = null;
-    this.currentState = null;
-    this.targetState = null;
-    assert('BUG: Missing owner', owner);
-    this._resetQueuedQueryParameterChanges();
-    this.namespace = owner.lookup('application:main');
-    let bucketCache = owner.lookup(P`-bucket-cache:main`);
-    assert('BUG: BucketCache should always be present', bucketCache instanceof BucketCache);
-    this._bucketCache = bucketCache;
-    let routerService = owner.lookup('service:router');
-    assert('BUG: RouterService should always be present', routerService !== undefined);
-    this._routerService = routerService;
-  }
   /**
     The `Router.map` function allows you to define mappings from URLs to routes
     in your application. These mappings are defined within the
@@ -171,6 +139,37 @@ class EmberRouter extends EmberObject.extend(Evented) {
     }
     return path.join('.');
   }
+  // Note that owner is actually required in this scenario, but since it is strictly
+  // optional in other contexts trying to make it required here confuses TS.
+  constructor(owner) {
+    super(owner);
+    this._didSetupRouter = false;
+    this._initialTransitionStarted = false;
+    this.currentURL = null;
+    this.currentRouteName = null;
+    this.currentPath = null;
+    this.currentRoute = null;
+    this._qpCache = Object.create(null);
+    // Set of QueryParam['urlKey']
+    this._qpUpdates = new Set();
+    this._queuedQPChanges = {};
+    this._toplevelView = null;
+    this._handledErrors = new Set();
+    this._engineInstances = Object.create(null);
+    this._engineInfoByRoute = Object.create(null);
+    this._slowTransitionTimer = null;
+    this.currentState = null;
+    this.targetState = null;
+    assert('BUG: Missing owner', owner);
+    this._resetQueuedQueryParameterChanges();
+    this.namespace = owner.lookup('application:main');
+    let bucketCache = owner.lookup(P`-bucket-cache:main`);
+    assert('BUG: BucketCache should always be present', bucketCache instanceof BucketCache);
+    this._bucketCache = bucketCache;
+    let routerService = owner.lookup('service:router');
+    assert('BUG: RouterService should always be present', routerService !== undefined);
+    this._routerService = routerService;
+  }
   _initRouterJs() {
     let location = get(this, 'location');
     let router = this;
@@ -1216,7 +1215,7 @@ function findRouteStateName(route, state) {
   is in the Router's map and the owner has a registration for that route.
 
   @private
-  @param {InternalOwner} owner
+  @param {Owner} owner
   @param {Router} router
   @param {String} localName
   @param {String} fullName
@@ -1224,7 +1223,7 @@ function findRouteStateName(route, state) {
 */
 function routeHasBeenDefined(owner, router, localName, fullName) {
   let routerHasRoute = router.hasRoute(fullName);
-  let ownerHasRoute = owner.hasRegistration(`template:${localName}`) || owner.hasRegistration(`route:${localName}`);
+  let ownerHasRoute = owner.factoryFor(`template:${localName}`) || owner.factoryFor(`route:${localName}`);
   return routerHasRoute && ownerHasRoute;
 }
 export function triggerEvent(routeInfos, ignoreFailure, name, args) {
@@ -1233,7 +1232,7 @@ export function triggerEvent(routeInfos, ignoreFailure, name, args) {
       return;
     }
     // TODO: update?
-    throw new EmberError(`Can't trigger action '${name}' because your app hasn't finished transitioning into its first route. To trigger an action on destination routes during a transition, you can call \`.send()\` on the \`Transition\` object passed to the \`model/beforeModel/afterModel\` hooks.`);
+    throw new Error(`Can't trigger action '${name}' because your app hasn't finished transitioning into its first route. To trigger an action on destination routes during a transition, you can call \`.send()\` on the \`Transition\` object passed to the \`model/beforeModel/afterModel\` hooks.`);
   }
   let eventWasHandled = false;
   let routeInfo, handler, actionHandler;
@@ -1261,7 +1260,7 @@ export function triggerEvent(routeInfos, ignoreFailure, name, args) {
     return;
   }
   if (!eventWasHandled && !ignoreFailure) {
-    throw new EmberError(`Nothing handled the action '${name}'. If you did handle the action, this error can be caused by returning true from an action handler in a controller, causing the action to bubble.`);
+    throw new Error(`Nothing handled the action '${name}'. If you did handle the action, this error can be caused by returning true from an action handler in a controller, causing the action to bubble.`);
   }
 }
 function calculatePostTransitionState(emberRouter, leafRouteName, contexts) {

package/dist/packages/ember/index.js

@@ -29,7 +29,7 @@ import DataAdapter from '@ember/debug/data-adapter';
 import EmberError from '@ember/error';
 import { run } from '@ember/runloop';
 import { getOnerror, setOnerror } from '@ember/-internals/error-handling';
-import EmberArray, { A, NativeArray, isArray } from '@ember/array';
+import EmberArray, { A, NativeArray, isArray, makeArray } from '@ember/array';
 import MutableArray from '@ember/array/mutable';
 import ArrayProxy from '@ember/array/proxy';
 import Application, { getOwner, setOwner, onLoad, runLoadHooks } from '@ember/application';
@@ -118,10 +118,8 @@ const PartialEmber = {
   _Cache: utils.Cache,
   GUID_KEY: utils.GUID_KEY,
   canInvoke: utils.canInvoke,
-  inspect: utils.inspect,
   generateGuid: utils.generateGuid,
   guidFor: utils.guidFor,
-  makeArray: utils.makeArray,
   uuid: utils.uuid,
   wrap: utils.wrap,
   // ****@ember/application****
@@ -139,6 +137,7 @@ const PartialEmber = {
   Array: EmberArray,
   NativeArray,
   isArray,
+  makeArray,
   // ****@ember/array/mutable****
   MutableArray,
   // ****@ember/array/proxy****
@@ -163,6 +162,7 @@ const PartialEmber = {
   deprecate: EmberDebug.deprecate,
   deprecateFunc: EmberDebug.deprecateFunc,
   runInDebug: EmberDebug.runInDebug,
+  inspect: EmberDebug.inspect,
   Debug: {
     registerDeprecationHandler: EmberDebug.registerDeprecationHandler,
     registerWarnHandler: EmberDebug.registerWarnHandler,

package/dist/packages/ember/version.js

@@ -1 +1 @@
-export default "4.10.0-beta.2";
+export default "4.11.0-alpha.2";

package/dist/packages/ember-testing/lib/adapters/qunit.js

@@ -1,5 +1,5 @@
 /* globals QUnit */
-import { inspect } from '@ember/-internals/utils';
+import { inspect } from '@ember/debug';
 import Adapter from './adapter';
 function isVeryOldQunit(obj) {
   return obj != null && typeof obj.stop === 'function';