ember-source 6.12.0 → 7.0.0-alpha.1

package/dist/{packages/shared-chunks/router-DSi8WnDi.js → dev/packages/router_js/index.js}

@@ -1,7 +1,8 @@
 import RouteRecognizer from '../route-recognizer/index.js';
-import { P as Promise$1 } from './rsvp-CnCSY930.js';
-import { Q as QUERY_PARAMS_SYMBOL, m as merge, i as isTransition, a as isParam, t as throwIfAborted, P as PARAMS_SYMBOL, p as prepareResult, b as isPromise, f as forEach, c as promiseLabel, U as UnrecognizedURLError, T as Transition, S as STATE_SYMBOL, g as getChangelist, d as log, l as logAbort, e as isTransitionAborted, h as extractQueryParams } from './unrecognized-url-error-BBMMZhBN.js';
+import { P as Promise$1 } from '../shared-chunks/rsvp-CnCSY930.js';
+import { Q as QUERY_PARAMS_SYMBOL, m as merge, i as isTransition, a as isParam, t as throwIfAborted, P as PARAMS_SYMBOL, p as prepareResult, b as isPromise, f as forEach, c as promiseLabel, U as UnrecognizedURLError, T as Transition, S as STATE_SYMBOL, g as getChangelist, d as log, l as logAbort, e as isTransitionAborted, h as extractQueryParams } from '../shared-chunks/unrecognized-url-error-B3wUTorp.js';
 
+/* eslint-disable no-prototype-builtins */
 let ROUTE_INFOS = new WeakMap();
 function toReadOnlyRouteInfo(routeInfos, queryParams = {}, options = {
   includeAttributes: false,
@@ -61,6 +62,7 @@ function toReadOnlyRouteInfo(routeInfos, queryParams = {}, options = {
         if (parent === undefined) {
           return null;
         }
+
         // SAFETY: This should be safe since it is just for use as a key
         return routeInfosRef.get(parent);
       },
@@ -69,6 +71,7 @@ function toReadOnlyRouteInfo(routeInfos, queryParams = {}, options = {
         if (child === undefined) {
           return null;
         }
+
         // SAFETY: This should be safe since it is just for use as a key
         return routeInfosRef.get(child);
       },
@@ -86,6 +89,7 @@ function toReadOnlyRouteInfo(routeInfos, queryParams = {}, options = {
     if (options.includeAttributes) {
       routeInfo = createRouteInfoWithAttributes(routeInfo, context);
     }
+
     // SAFETY: This should be safe since it is just for use as a key
     LOCAL_ROUTE_INFOS.set(info, routeInfo);
     if (!options.localizeMapUpdates) {
@@ -124,11 +128,12 @@ function attachMetadata(route, routeInfo) {
   return Object.assign(routeInfo, metadata);
 }
 class InternalRouteInfo {
+  _routePromise = undefined;
+  _route = null;
+  router;
+  params = {};
+  isResolved = false;
   constructor(router, name, paramNames, route) {
-    this._routePromise = undefined;
-    this._route = null;
-    this.params = {};
-    this.isResolved = false;
     this.name = name;
     this.paramNames = paramNames;
     this.router = router;
@@ -163,6 +168,7 @@ class InternalRouteInfo {
     if ('context' in this || !contextsMatch) {
       context = resolvedContext;
     }
+
     // SAFETY: Since this is just for lookup, it should be safe
     let cached = ROUTE_INFOS.get(this);
     let resolved = new ResolvedRouteInfo(this.router, this.name, this.paramNames, params, this.route, context);
@@ -263,6 +269,7 @@ class InternalRouteInfo {
   _processRoute(route) {
     // Setup a routePromise so that we can wait for asynchronously loaded routes
     this.routePromise = Promise$1.resolve(route);
+
     // Wait until the 'route' property has been updated when chaining to a route
     // that is a promise
     if (isPromise(route)) {
@@ -278,6 +285,8 @@ class InternalRouteInfo {
   }
 }
 class ResolvedRouteInfo extends InternalRouteInfo {
+  isResolved;
+  context;
   constructor(router, name, paramNames, params, route, context) {
     super(router, name, paramNames, route);
     this.params = params;
@@ -293,9 +302,9 @@ class ResolvedRouteInfo extends InternalRouteInfo {
   }
 }
 class UnresolvedRouteInfoByParam extends InternalRouteInfo {
+  params = {};
   constructor(router, name, paramNames, params, route) {
     super(router, name, paramNames, route);
-    this.params = {};
     if (params) {
       this.params = params;
     }
@@ -305,10 +314,11 @@ class UnresolvedRouteInfoByParam extends InternalRouteInfo {
     if (transition && transition[QUERY_PARAMS_SYMBOL]) {
       fullParams = {};
       merge(fullParams, this.params);
-      fullParams.queryParams = transition[QUERY_PARAMS_SYMBOL];
+      fullParams['queryParams'] = transition[QUERY_PARAMS_SYMBOL];
     }
     let route = this.route;
     let result;
+
     // FIXME: Review these casts
     if (route.deserialize) {
       result = route.deserialize(fullParams, transition);
@@ -322,6 +332,7 @@ class UnresolvedRouteInfoByParam extends InternalRouteInfo {
   }
 }
 class UnresolvedRouteInfoByObject extends InternalRouteInfo {
+  serializer;
   constructor(router, name, paramNames, context) {
     super(router, name, paramNames);
     this.context = context;
@@ -333,12 +344,13 @@ class UnresolvedRouteInfoByObject extends InternalRouteInfo {
     }
     return super.getModel(transition);
   }
+
   /**
     @private
-       Serializes a route using its custom `serialize` method or
+     Serializes a route using its custom `serialize` method or
     by a default that looks up the expected property name from
     the dynamic segment.
-       @param {Object} model the model to be serialized for this route
+     @param {Object} model the model to be serialized for this route
   */
   serialize(model) {
     let {
@@ -355,6 +367,7 @@ class UnresolvedRouteInfoByObject extends InternalRouteInfo {
       object[paramNames[0]] = model;
       return object;
     }
+
     // Use custom serialize if it exists.
     if (this.serializer) {
       // invoke this.serializer unbound (getSerializer returns a stateless function)
@@ -386,6 +399,7 @@ function paramsMatch(a, b) {
     // Only one is undefined, already checked they aren't identical
     return false;
   }
+
   // Note: this assumes that both params have the same
   // number of keys, but since we're comparing the
   // same routes, they should.
@@ -398,10 +412,13 @@ function paramsMatch(a, b) {
 }
 
 class TransitionIntent {
+  data;
+  router;
   constructor(router, data = {}) {
     this.router = router;
     this.data = data;
   }
+  preTransitionState;
 }
 
 function handleError(currentState, transition, error) {
@@ -424,6 +441,7 @@ function resolveOneRouteInfo(currentState, transition) {
 }
 function proceed(currentState, transition, resolvedRouteInfo) {
   let wasAlreadyResolved = currentState.routeInfos[transition.resolveIndex].isResolved;
+
   // Swap the previously unresolved routeInfo with
   // the resolved routeInfo
   currentState.routeInfos[transition.resolveIndex++] = resolvedRouteInfo;
@@ -441,17 +459,16 @@ function proceed(currentState, transition, resolvedRouteInfo) {
       }
     }
   }
+
   // Proceed after ensuring that the redirect hook
   // didn't abort this transition by transitioning elsewhere.
   throwIfAborted(transition);
   return resolveOneRouteInfo(currentState, transition);
 }
 class TransitionState {
-  constructor() {
-    this.routeInfos = [];
-    this.queryParams = {};
-    this.params = {};
-  }
+  routeInfos = [];
+  queryParams = {};
+  params = {};
   promiseLabel(label) {
     let targetName = '';
     forEach(this.routeInfos, function (routeInfo) {
@@ -474,6 +491,7 @@ class TransitionState {
     transition.resolveIndex = 0;
     let callback = resolveOneRouteInfo.bind(null, this, transition);
     let errorHandler = handleError.bind(null, this, transition);
+
     // The prelude RSVP.resolve() async moves us into the promise land.
     return Promise$1.resolve(null, this.promiseLabel('Start transition')).then(callback, null, this.promiseLabel('Resolve route')).catch(errorHandler, this.promiseLabel('Handle error')).then(() => this);
   }
@@ -487,10 +505,16 @@ class TransitionError {
   }
 }
 
+/* eslint-disable no-prototype-builtins */
+
 class NamedTransitionIntent extends TransitionIntent {
+  name;
+  pivotHandler;
+  contexts;
+  queryParams;
+  preTransitionState = undefined;
   constructor(router, name, pivotHandler, contexts = [], queryParams = {}, data) {
     super(router, data);
-    this.preTransitionState = undefined;
     this.name = name;
     this.pivotHandler = pivotHandler;
     this.contexts = contexts;
@@ -506,6 +530,7 @@ class NamedTransitionIntent extends TransitionIntent {
     let newState = new TransitionState();
     let objects = this.contexts.slice(0);
     let invalidateIndex = parsedHandlers.length;
+
     // Pivot handlers are provided for refresh transitions
     if (this.pivotHandler) {
       for (i = 0, len = parsedHandlers.length; i < len; ++i) {
@@ -603,7 +628,7 @@ class NamedTransitionIntent extends TransitionIntent {
     } else {
       if (this.preTransitionState) {
         let preTransitionHandlerInfo = this.preTransitionState.routeInfos[i];
-        objectToUse = preTransitionHandlerInfo === null || preTransitionHandlerInfo === void 0 ? void 0 : preTransitionHandlerInfo.context;
+        objectToUse = preTransitionHandlerInfo?.context;
       } else {
         // Ideally we should throw this error to provide maximal
         // information to the user that not enough context objects
@@ -619,6 +644,7 @@ class NamedTransitionIntent extends TransitionIntent {
   }
   createParamHandlerInfo(name, names, objects, oldHandlerInfo) {
     let params = {};
+
     // Soak up all the provided string/numbers
     let numNames = names.length;
     let missingParams = [];
@@ -628,7 +654,7 @@ class NamedTransitionIntent extends TransitionIntent {
       let peek = objects[objects.length - 1];
       let paramName = names[numNames];
       if (isParam(peek)) {
-        params[paramName] = '' + objects.pop();
+        params[paramName] = String(objects.pop());
       } else {
         // If we're here, this means only some of the params
         // were string/number params, so try and use a param
@@ -648,6 +674,8 @@ class NamedTransitionIntent extends TransitionIntent {
 }
 
 class URLTransitionIntent extends TransitionIntent {
+  preTransitionState;
+  url;
   constructor(router, url, data) {
     super(router, data);
     this.url = url;
@@ -663,6 +691,7 @@ class URLTransitionIntent extends TransitionIntent {
     }
     let statesDiffer = false;
     let _url = this.url;
+
     // Checks if a handler is accessible by URL. If it is not, an error is thrown.
     // For the case where the handler is loaded asynchronously, the error will be
     // thrown once it is loaded.
@@ -701,15 +730,19 @@ class URLTransitionIntent extends TransitionIntent {
   }
 }
 
+/* eslint-disable no-prototype-builtins */
+
 class Router {
+  _lastQueryParams = {};
+  log;
+  state = undefined;
+  oldState = undefined;
+  activeTransition = undefined;
+  currentRouteInfos = undefined;
+  _changedQueryParams = undefined;
+  currentSequence = 0;
+  recognizer;
   constructor(logger) {
-    this._lastQueryParams = {};
-    this.state = undefined;
-    this.oldState = undefined;
-    this.activeTransition = undefined;
-    this.currentRouteInfos = undefined;
-    this._changedQueryParams = undefined;
-    this.currentSequence = 0;
     this.log = logger;
     this.recognizer = new RouteRecognizer();
     this.reset();
@@ -717,9 +750,9 @@ class Router {
   /**
     The main entry point into the router. The API is essentially
     the same as the `map` method in `route-recognizer`.
-       This method extracts the String handler at the last `.to()`
+     This method extracts the String handler at the last `.to()`
     call and uses it as the name of the whole route.
-       @param {Function} callback
+     @param {Function} callback
   */
   map(callback) {
     this.recognizer.map(callback, function (recognizer, routes) {
@@ -745,6 +778,7 @@ class Router {
     } else {
       // Running queryParamsDidChange didn't change anything.
       // Just update query params and be on our way.
+
       // We have to return a noop transition that will
       // perform a URL update at the end. This gives
       // the user the ability to set the url update
@@ -804,12 +838,12 @@ class Router {
   generateNewState(intent) {
     try {
       return intent.applyToState(this.state, false);
-    } catch (e) {
+    } catch (_e) {
       return null;
     }
   }
   getTransitionByIntent(intent, isIntermediate) {
-    let wasTransitioning = !!this.activeTransition;
+    let wasTransitioning = Boolean(this.activeTransition);
     let oldState = wasTransitioning ? this.activeTransition[STATE_SYMBOL] : this.state;
     let newTransition;
     let newState = intent.applyToState(oldState, isIntermediate);
@@ -822,6 +856,7 @@ class Router {
         // SAFETY: The returned OpaqueTransition should actually be this.
         return newTransition;
       }
+
       // No-op. No need to create a new transition.
       return this.activeTransition || new Transition(this, undefined, undefined);
     }
@@ -833,8 +868,10 @@ class Router {
       this.routeWillChange(transition);
       return this.activeTransition;
     }
+
     // Create a new transition to the destination route.
     newTransition = new Transition(this, intent, newState, undefined, this.activeTransition);
+
     // transition is to same route with same params, only query params differ.
     // not caught above probably because refresh() has been used
     if (routeInfosSameExceptQueryParams(newState.routeInfos, oldState.routeInfos)) {
@@ -846,6 +883,7 @@ class Router {
       this.activeTransition.redirect(newTransition);
     }
     this.activeTransition = newTransition;
+
     // Transition promises by default resolve with resolved state.
     // For our purposes, swap out the promise to resolve
     // after the transition has been finalized.
@@ -858,12 +896,13 @@ class Router {
     this.fireQueryParamDidChange(newState, queryParamChangelist);
     return newTransition;
   }
+
   /**
   @private
-     Begins and returns a Transition based on the provided
+   Begins and returns a Transition based on the provided
   arguments. Accepts arguments in the form of both URL
   transitions and named transitions.
-     @param {Router} router
+   @param {Router} router
   @param {Array[Object]} args arguments passed to transitionTo,
     replaceWith, or handleURL
   */
@@ -878,6 +917,7 @@ class Router {
     let intent;
     if (name === undefined) {
       log(this, 'Updating query params');
+
       // A query param update is really just a transition
       // into the route you're already on.
       let {
@@ -895,17 +935,20 @@ class Router {
     }
     return this.transitionByIntent(intent, isIntermediate);
   }
+
   /**
   @private
-     Updates the URL (if necessary) and calls `setupContexts`
+   Updates the URL (if necessary) and calls `setupContexts`
   to update the router's array of `currentRouteInfos`.
   */
   finalizeTransition(transition, newState) {
     try {
       log(transition.router, transition.sequence, 'Resolved all models on destination route; finalizing transition.');
       let routeInfos = newState.routeInfos;
+
       // Run all the necessary enter/setup/exit hooks
       this.setupContexts(newState, transition);
+
       // Check if a redirect occurred in enter/setup
       if (transition.isAborted) {
         // TODO: cleaner way? distinguish b/w targetRouteInfos?
@@ -920,6 +963,7 @@ class Router {
       this.toInfos(transition, newState.routeInfos, true);
       this.routeDidChange(transition);
       log(this, transition.sequence, 'TRANSITION COMPLETE.');
+
       // Resolve with the final route.
       return routeInfos[routeInfos.length - 1].route;
     } catch (e) {
@@ -931,14 +975,15 @@ class Router {
       throw e;
     }
   }
+
   /**
   @private
-     Takes an Array of `RouteInfo`s, figures out which ones are
+   Takes an Array of `RouteInfo`s, figures out which ones are
   exiting, entering, or changing contexts, and calls the
   proper route hooks.
-     For example, consider the following tree of routes. Each route is
+   For example, consider the following tree of routes. Each route is
   followed by the URL segment it handles.
-     ```
+   ```
   |~index ("/")
   | |~posts ("/posts")
   | | |-showPost ("/:id")
@@ -946,8 +991,8 @@ class Router {
   | | |-editPost ("/edit")
   | |~about ("/about/:id")
   ```
-     Consider the following transitions:
-     1. A URL transition to `/posts/1`.
+   Consider the following transitions:
+   1. A URL transition to `/posts/1`.
      1. Triggers the `*model` callbacks on the
         `index`, `posts`, and `showPost` routes
      2. Triggers the `enter` callback on the same
@@ -963,7 +1008,7 @@ class Router {
      2. Triggers the `serialize` callback on `about`
      3. Triggers the `enter` callback on `about`
      4. Triggers the `setup` callback on `about`
-     @param {Router} transition
+   @param {Router} transition
   @param {TransitionState} newState
   */
   setupContexts(newState, transition) {
@@ -1006,9 +1051,10 @@ class Router {
     }
     this.state.queryParams = this.finalizeQueryParamChange(currentRouteInfos, newState.queryParams, transition);
   }
+
   /**
   @private
-     Fires queryParamsDidChange event
+   Fires queryParamsDidChange event
   */
   fireQueryParamDidChange(newState, queryParamChangelist) {
     // If queryParams changed trigger event
@@ -1021,9 +1067,10 @@ class Router {
       this._changedQueryParams = undefined;
     }
   }
+
   /**
   @private
-     Helper method used by setupContexts. Handles errors or redirects
+   Helper method used by setupContexts. Handles errors or redirects
   that may happen in enter/setup.
   */
   routeEnteredOrUpdated(currentRouteInfos, routeInfo, enter, transition) {
@@ -1047,6 +1094,7 @@ class Router {
       currentRouteInfos.push(routeInfo);
       return route;
     }
+
     // If the route doesn't exist, it means we haven't resolved the route promise yet
     if (route === undefined) {
       routeInfo.routePromise = routeInfo.routePromise.then(_routeEnteredOrUpdated);
@@ -1055,15 +1103,16 @@ class Router {
     }
     return true;
   }
+
   /**
   @private
-     This function is called when transitioning from one URL to
+   This function is called when transitioning from one URL to
   another to determine which routes are no longer active,
   which routes are newly active, and which routes remain
   active but have their context changed.
-     Take a list of old routes and new routes and partition
+   Take a list of old routes and new routes and partition
   them into four buckets:
-     * unchanged: the route was active in both the old and
+   * unchanged: the route was active in both the old and
     new URL, and its context remains the same
   * updated context: the route was active in both the
     old and new URL, but its context changed. The route's
@@ -1073,8 +1122,8 @@ class Router {
     no longer active.
   * entered: the route was not active in the old URL, but
     is now active.
-     The PartitionedRoutes structure has four fields:
-     * `updatedContext`: a list of `RouteInfo` objects that
+   The PartitionedRoutes structure has four fields:
+   * `updatedContext`: a list of `RouteInfo` objects that
     represent routes that remain active but have a changed
     context
   * `entered`: a list of `RouteInfo` objects that represent
@@ -1082,12 +1131,12 @@ class Router {
   * `exited`: a list of `RouteInfo` objects that are no
     longer active.
   * `unchanged`: a list of `RouteInfo` objects that remain active.
-     @param {Array[InternalRouteInfo]} oldRoutes a list of the route
+   @param {Array[InternalRouteInfo]} oldRoutes a list of the route
     information for the previous URL (or `[]` if this is the
     first handled transition)
   @param {Array[InternalRouteInfo]} newRoutes a list of the route
     information for the new URL
-     @return {Partition}
+   @return {Partition}
   */
   partitionRoutes(oldState, newState) {
     let oldRouteInfos = oldState.routeInfos;
@@ -1148,8 +1197,9 @@ class Router {
       }
     }
     if (urlMethod) {
-      params.queryParams = transition._visibleQueryParams || state.queryParams;
+      params['queryParams'] = transition._visibleQueryParams || state.queryParams;
       let url = this.recognizer.generate(routeName, params);
+
       // transitions during the initial transition must always use replaceURL.
       // When the app boots, you are at a url, e.g. /foo. If some route
       // redirects to bar as part of the initial transition, you don't want to
@@ -1157,6 +1207,7 @@ class Router {
       // hit the redirect again and take you back to /bar, thus killing the back
       // button
       let initial = transition.isCausedByInitialTransition;
+
       // say you are at / and you click a link to route /foo. In /foo's
       // route, the transition is aborted using replaceWith('/bar').
       // Because the current url is still /, the history entry for / is
@@ -1165,10 +1216,12 @@ class Router {
       // the back button. That's why updateURL is always correct for an
       // aborting transition that's not the initial transition
       let replaceAndNotAborting = urlMethod === 'replace' && !transition.isCausedByAbortingTransition;
+
       // because calling refresh causes an aborted transition, this needs to be
       // special cased - if the initial transition is a replace transition, the
       // urlMethod should be honored here.
       let isQueryParamsRefreshTransition = transition.queryParamsOnly && urlMethod === 'replace';
+
       // say you are at / and you a `replaceWith(/foo)` is called. Then, that
       // transition is aborted with `replaceWith(/bar)`. At the end, we should
       // end up with /bar replacing /. We are replacing the replace. We only
@@ -1191,6 +1244,7 @@ class Router {
     // no longer consumed in the final route hierarchy,
     // its serialized segment will be removed
     // from the URL.
+
     for (let k in newQueryParams) {
       if (newQueryParams.hasOwnProperty(k) && newQueryParams[k] === null) {
         delete newQueryParams[k];
@@ -1254,6 +1308,7 @@ class Router {
     this.routeWillChange(newTransition);
     this.willTransition(oldRouteInfos, newState.routeInfos, newTransition);
   }
+
   /**
     Clears the current and target route routes and triggers exit
     on each of them starting at the leaf and traversing up through
@@ -1275,14 +1330,15 @@ class Router {
     this.state = new TransitionState();
     this.currentRouteInfos = undefined;
   }
+
   /**
     let handler = routeInfo.handler;
     The entry point for handling a change to the URL (usually
     via the back and forward button).
-       Returns an Array of handlers and the parameters associated
+     Returns an Array of handlers and the parameters associated
     with those parameters.
-       @param {String} url a URL to process
-       @return {Array} an Array of `[handler, parameter]` tuples
+     @param {String} url a URL to process
+     @return {Array} an Array of `[handler, parameter]` tuples
   */
   handleURL(url) {
     // Perform a URL-based transition, but don't change
@@ -1292,11 +1348,12 @@ class Router {
     }
     return this.doTransition(url).method(null);
   }
+
   /**
     Transition into the specified named route.
-       If necessary, trigger the exit callback on any routes
+     If necessary, trigger the exit callback on any routes
     that are no longer represented by the target route.
-       @param {String} name the name of the route
+     @param {String} name the name of the route
   */
   transitionTo(name, ...contexts) {
     if (typeof name === 'object') {
@@ -1319,33 +1376,37 @@ class Router {
     let name = routeInfos[routeInfos.length - 1].name;
     let intent = new NamedTransitionIntent(this, name, pivotRoute, [], this._changedQueryParams || state.queryParams);
     let newTransition = this.transitionByIntent(intent, false);
+
     // if the previous transition is a replace transition, that needs to be preserved
     if (previousTransition && previousTransition.urlMethod === 'replace') {
       newTransition.method(previousTransition.urlMethod);
     }
     return newTransition;
   }
+
   /**
     Identical to `transitionTo` except that the current URL will be replaced
     if possible.
-       This method is intended primarily for use with `replaceState`.
-       @param {String} name the name of the route
+     This method is intended primarily for use with `replaceState`.
+     @param {String} name the name of the route
   */
   replaceWith(name) {
     return this.doTransition(name).method('replace');
   }
+
   /**
     Take a named route and context objects and generate a
     URL.
-       @param {String} name the name of the route to generate
+     @param {String} name the name of the route to generate
       a URL for
     @param {...Object} objects a list of objects to serialize
-       @return {String} a URL
+     @return {String} a URL
   */
   generate(routeName, ...args) {
     let partitionedArgs = extractQueryParams(args),
       suppliedParams = partitionedArgs[0],
       queryParams = partitionedArgs[1];
+
     // Construct a TransitionIntent with the provided params
     // and apply it to the present state of the router.
     let intent = new NamedTransitionIntent(this, routeName, undefined, suppliedParams);
@@ -1394,6 +1455,7 @@ class Router {
     if (!queryParams || !routesEqual) {
       return routesEqual;
     }
+
     // Get a hash of QPs that will still be active on new route
     let activeQPsOnNewHandler = {};
     merge(activeQPsOnNewHandler, queryParams);
@@ -1462,4 +1524,4 @@ function paramsEqual(params, otherParams) {
   return true;
 }
 
-export { InternalRouteInfo as I, Router as R, TransitionError as T, TransitionState as a };
+export { InternalRouteInfo, Transition as InternalTransition, PARAMS_SYMBOL, QUERY_PARAMS_SYMBOL, STATE_SYMBOL, TransitionError, TransitionState, Router as default, logAbort };

package/dist/{packages/shared-chunks/alias-BEMS3qgG.js → dev/packages/shared-chunks/alias-CSC0WIbj.js}

@@ -1,14 +1,13 @@
 import { meta } from '../@ember/-internals/meta/lib/meta.js';
 import '../@ember/debug/index.js';
 import { tagMetaFor, tagFor, untrack, validateTag, updateTag as UPDATE_TAG, valueForTag, consumeTag } from '../@glimmer/validator/index.js';
-import { i as isElementDescriptor, H as makeComputedDecorator, E as descriptorForDecorator, J as ComputedDescriptor, K as CHAIN_PASS_THROUGH, g as get, L as getChainTagsForKey, M as finishLazyChains, d as defineProperty } from './observers-DhgQ6ba5.js';
-import { s as set } from './property_set-DrZnfGQ7.js';
-import { isDevelopingApp } from '@embroider/macros';
+import { i as isElementDescriptor, G as makeComputedDecorator, B as descriptorForDecorator, I as ComputedDescriptor, J as CHAIN_PASS_THROUGH, g as get, K as getChainTagsForKey, L as finishLazyChains, d as defineProperty } from './observers-Bj9qLVau.js';
+import { s as set } from './property_set-DaoZXGM5.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 import inspect from '../@ember/debug/lib/inspect.js';
 
 function alias(altKey) {
-  (isDevelopingApp() && !(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @alias as a decorator directly, but it requires a `altKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments)))); // SAFETY: We passed in the impl for this class
+  (!(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @alias as a decorator directly, but it requires a `altKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments)))); // SAFETY: We passed in the impl for this class
   return makeComputedDecorator(new AliasedProperty(altKey), AliasDecoratorImpl);
 }
 
@@ -38,7 +37,7 @@ class AliasedProperty extends ComputedDescriptor {
     this.altKey = altKey;
   }
   setup(obj, keyName, propertyDesc, meta) {
-    (isDevelopingApp() && !(this.altKey !== keyName) && assert(`Setting alias '${keyName}' on self`, this.altKey !== keyName));
+    (!(this.altKey !== keyName) && assert(`Setting alias '${keyName}' on self`, this.altKey !== keyName));
     super.setup(obj, keyName, propertyDesc, meta);
     CHAIN_PASS_THROUGH.add(this);
   }