ember-source 4.3.0-alpha.3 → 4.3.0-beta.2

package/CHANGELOG.md

@@ -1,8 +1,16 @@
 # Ember Changelog
 
-### v4.2.0-beta.1 (December 28, 2021)
+### v4.3.0-beta.2 (March 1, 2022)
 
-- [#19878](https://github.com/emberjs/ember.js/pull/19772) [BUGFIX] Allow class-based helpers to work in strict-mode.
+- [#19971](https://github.com/emberjs/ember.js/pull/19971) [BUGFIX] Don't serialize default Query Params on RouterService
+
+### v4.3.0-beta.1 (February 7, 2022)
+
+No public API changes or bugfixes. 
+
+### v4.2.0 (February 7, 2022)
+
+- [#19878](https://github.com/emberjs/ember.js/pull/19878) [BUGFIX] Allow class-based helpers to work in strict-mode.
 
 ### v4.1.0 (December 28, 2021)
 

package/build-metadata.json

@@ -1,6 +1,6 @@
 {
-  "version": "4.3.0-alpha.3",
+  "version": "4.3.0-beta.2",
   "buildType": "tag",
-  "SHA": "096553840bf5cdb6dacb2556f746fe0ef0ab498d",
-  "assetPath": "/tag/shas/096553840bf5cdb6dacb2556f746fe0ef0ab498d.tgz"
+  "SHA": "f4b50b5134f125d32b95e2900631bc24f7ccffd6",
+  "assetPath": "/tag/shas/f4b50b5134f125d32b95e2900631bc24f7ccffd6.tgz"
 }

package/dist/dependencies/router_js.js

@@ -48,16 +48,22 @@ function extractQueryParams(array) {
     let len = array && array.length, head, queryParams;
     if (len && len > 0) {
         let obj = array[len - 1];
-        if (isQueryParams(obj)) {
+        if (isQueryParamsContainer(obj)) {
             queryParams = obj.queryParams;
             head = slice.call(array, 0, len - 1);
             return [head, queryParams];
         }
     }
+    // SAFETY: We confirmed that the last item isn't a QP container
     return [array, null];
 }
-function isQueryParams(obj) {
-    return obj && hasOwnProperty.call(obj, 'queryParams');
+// TODO: Actually check that Dict is QueryParams
+function isQueryParamsContainer(obj) {
+    if (obj && typeof obj === 'object') {
+        let cast = obj;
+        return ('queryParams' in cast && Object.keys(cast.queryParams).every((k) => typeof k === 'string'));
+    }
+    return false;
 }
 /**
   @private
@@ -498,11 +504,13 @@ let ROUTE_INFOS = new WeakMap();
 function toReadOnlyRouteInfo(routeInfos, queryParams = {}, includeAttributes = false) {
     return routeInfos.map((info, i) => {
         let { name, params, paramNames, context, route } = info;
-        if (ROUTE_INFOS.has(info) && includeAttributes) {
-            let routeInfo = ROUTE_INFOS.get(info);
+        // SAFETY: This should be safe since it is just for use as a key
+        let key = info;
+        if (ROUTE_INFOS.has(key) && includeAttributes) {
+            let routeInfo = ROUTE_INFOS.get(key);
             routeInfo = attachMetadata(route, routeInfo);
             let routeInfoWithAttribute = createRouteInfoWithAttributes(routeInfo, context);
-            ROUTE_INFOS.set(info, routeInfoWithAttribute);
+            ROUTE_INFOS.set(key, routeInfoWithAttribute);
             return routeInfoWithAttribute;
         }
         let routeInfo = {
@@ -510,9 +518,12 @@ function toReadOnlyRouteInfo(routeInfos, queryParams = {}, includeAttributes = f
                 let publicInfo;
                 let arr = [];
                 if (predicate.length === 3) {
-                    arr = routeInfos.map((info) => ROUTE_INFOS.get(info));
+                    arr = routeInfos.map(
+                    // SAFETY: This should be safe since it is just for use as a key
+                    (info) => ROUTE_INFOS.get(info));
                 }
                 for (let i = 0; routeInfos.length > i; i++) {
+                    // SAFETY: This should be safe since it is just for use as a key
                     publicInfo = ROUTE_INFOS.get(routeInfos[i]);
                     if (predicate.call(thisArg, publicInfo, i, arr)) {
                         return publicInfo;
@@ -534,6 +545,7 @@ function toReadOnlyRouteInfo(routeInfos, queryParams = {}, includeAttributes = f
                 if (parent === undefined) {
                     return null;
                 }
+                // SAFETY: This should be safe since it is just for use as a key
                 return ROUTE_INFOS.get(parent);
             },
             get child() {
@@ -541,6 +553,7 @@ function toReadOnlyRouteInfo(routeInfos, queryParams = {}, includeAttributes = f
                 if (child === undefined) {
                     return null;
                 }
+                // SAFETY: This should be safe since it is just for use as a key
                 return ROUTE_INFOS.get(child);
             },
             get localName() {
@@ -557,6 +570,7 @@ function toReadOnlyRouteInfo(routeInfos, queryParams = {}, includeAttributes = f
         if (includeAttributes) {
             routeInfo = createRouteInfoWithAttributes(routeInfo, context);
         }
+        // SAFETY: This should be safe since it is just for use as a key
         ROUTE_INFOS.set(info, routeInfo);
         return routeInfo;
     });
@@ -636,10 +650,12 @@ 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);
         if (cached !== undefined) {
-            ROUTE_INFOS.set(resolved, cached);
+            // SAFETY: This is potentially a bit risker, but for what we're doing, it should be ok.
+            ROUTE_INFOS.set(this, cached);
         }
         return resolved;
     }
@@ -720,11 +736,13 @@ class InternalRouteInfo {
             // Ignore the fulfilled value returned from afterModel.
             // Return the value stashed in resolvedModels, which
             // might have been swapped out in afterModel.
+            // SAFTEY: We expect this to be of type T, though typing it as such is challenging.
             return transition.resolvedModels[name];
         });
     }
     stashResolvedModel(transition, resolvedModel) {
         transition.resolvedModels = transition.resolvedModels || {};
+        // SAFETY: It's unfortunate that we have to do this cast. It should be safe though.
         transition.resolvedModels[this.name] = resolvedModel;
     }
     fetchRoute() {
@@ -768,7 +786,9 @@ class UnresolvedRouteInfoByParam extends InternalRouteInfo {
     constructor(router, name, paramNames, params, route) {
         super(router, name, paramNames, route);
         this.params = {};
-        this.params = params;
+        if (params) {
+            this.params = params;
+        }
     }
     getModel(transition) {
         let fullParams = this.params;
@@ -779,6 +799,7 @@ class UnresolvedRouteInfoByParam extends InternalRouteInfo {
         }
         let route = this.route;
         let result;
+        // FIXME: Review these casts
         if (route.deserialize) {
             result = route.deserialize(fullParams, transition);
         }
@@ -815,6 +836,8 @@ class UnresolvedRouteInfoByObject extends InternalRouteInfo {
     serialize(model) {
         let { paramNames, context } = this;
         if (!model) {
+            // SAFETY: By the time we serialize, we expect to be resolved.
+            // This may not be an entirely safe assumption though no tests fail.
             model = context;
         }
         let object = {};
@@ -837,6 +860,7 @@ class UnresolvedRouteInfoByObject extends InternalRouteInfo {
         }
         let name = paramNames[0];
         if (/_id$/.test(name)) {
+            // SAFETY: Model is supposed to extend IModel already
             object[name] = model.id;
         }
         else {
@@ -846,14 +870,14 @@ class UnresolvedRouteInfoByObject extends InternalRouteInfo {
     }
 }
 function paramsMatch(a, b) {
-    if (!a !== !b) {
-        // Only one is null.
-        return false;
-    }
-    if (!a) {
-        // Both must be null.
+    if (a === b) {
+        // Both are identical, may both be undefined
         return true;
     }
+    if (!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.
@@ -887,9 +911,8 @@ function resolveOneRouteInfo(currentState, transition) {
         return;
     }
     let routeInfo = currentState.routeInfos[transition.resolveIndex];
-    return routeInfo
-        .resolve(transition)
-        .then(proceed.bind(null, currentState, transition), null, currentState.promiseLabel('Proceed'));
+    let callback = proceed.bind(null, currentState, transition);
+    return routeInfo.resolve(transition).then(callback, null, currentState.promiseLabel('Proceed'));
 }
 function proceed(currentState, transition, resolvedRouteInfo) {
     let wasAlreadyResolved = currentState.routeInfos[transition.resolveIndex].isResolved;
@@ -939,10 +962,12 @@ class TransitionState {
             return true;
         });
         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.resolve(null, this.promiseLabel('Start transition'))
-            .then(resolveOneRouteInfo.bind(null, this, transition), null, this.promiseLabel('Resolve route'))
-            .catch(handleError.bind(null, this, transition), this.promiseLabel('Handle error'))
+            .then(callback, null, this.promiseLabel('Resolve route'))
+            .catch(errorHandler, this.promiseLabel('Handle error'))
             .then(() => this);
     }
 }
@@ -965,8 +990,7 @@ class NamedTransitionIntent extends TransitionIntent {
         this.queryParams = queryParams;
     }
     applyToState(oldState, isIntermediate) {
-        // TODO: WTF fix me
-        let partitionedArgs = extractQueryParams([this.name].concat(this.contexts)), pureArgs = partitionedArgs[0], handlers = this.router.recognizer.handlersFor(pureArgs[0]);
+        let handlers = this.router.recognizer.handlersFor(this.name);
         let targetRouteName = handlers[handlers.length - 1].handler;
         return this.applyToHandlers(oldState, handlers, targetRouteName, isIntermediate, false);
     }
@@ -1008,7 +1032,9 @@ class NamedTransitionIntent extends TransitionIntent {
                 // If we're performing an isActive check, we want to
                 // serialize URL params with the provided context, but
                 // ignore mismatches between old and new context.
-                newHandlerInfo = newHandlerInfo.becomeResolved(null, newHandlerInfo.context);
+                newHandlerInfo = newHandlerInfo.becomeResolved(null, 
+                // SAFETY: This seems to imply that it would be resolved, but it's unclear if that's actually the case.
+                newHandlerInfo.context);
                 let oldContext = oldHandlerInfo && oldHandlerInfo.context;
                 if (result.names.length > 0 &&
                     oldHandlerInfo.context !== undefined &&
@@ -1026,7 +1052,9 @@ class NamedTransitionIntent extends TransitionIntent {
                 handlerToUse = newHandlerInfo;
             }
             if (isIntermediate && !checkingIfActive) {
-                handlerToUse = handlerToUse.becomeResolved(null, handlerToUse.context);
+                handlerToUse = handlerToUse.becomeResolved(null, 
+                // SAFETY: This seems to imply that it would be resolved, but it's unclear if that's actually the case.
+                handlerToUse.context);
             }
             newState.routeInfos.unshift(handlerToUse);
         }
@@ -1071,7 +1099,7 @@ class NamedTransitionIntent extends TransitionIntent {
         else {
             if (this.preTransitionState) {
                 let preTransitionHandlerInfo = this.preTransitionState.routeInfos[i];
-                objectToUse = preTransitionHandlerInfo && preTransitionHandlerInfo.context;
+                objectToUse = preTransitionHandlerInfo === null || preTransitionHandlerInfo === void 0 ? void 0 : preTransitionHandlerInfo.context;
             }
             else {
                 // Ideally we should throw this error to provide maximal
@@ -1305,6 +1333,7 @@ class Router {
             if (queryParamChangelist) {
                 let newTransition = this.queryParamsTransition(queryParamChangelist, wasTransitioning, oldState, newState);
                 newTransition.queryParamsOnly = true;
+                // SAFETY: The returned OpaqueTransition should actually be this.
                 return newTransition;
             }
             // No-op. No need to create a new transition.
@@ -1358,6 +1387,8 @@ class Router {
         let lastArg = modelsArray[modelsArray.length - 1];
         let queryParams = {};
         if (lastArg !== undefined && lastArg.hasOwnProperty('queryParams')) {
+            // We just checked this.
+            // TODO: Use an assertion?
             queryParams = modelsArray.pop().queryParams;
         }
         let intent;
@@ -1374,7 +1405,9 @@ class Router {
         }
         else {
             log(this, 'Attempting transition to ' + name);
-            intent = new NamedTransitionIntent(this, name, undefined, modelsArray, queryParams);
+            intent = new NamedTransitionIntent(this, name, undefined, 
+            // SAFETY: We know this to be the case since we removed the last item if it was QPs
+            modelsArray, queryParams);
         }
         return this.transitionByIntent(intent, isIntermediate);
     }
@@ -1905,8 +1938,8 @@ class Router {
         return routesEqual && !getChangelist(activeQPsOnNewHandler, queryParams);
     }
     isActive(routeName, ...args) {
-        let partitionedArgs = extractQueryParams(args);
-        return this.isActiveIntent(routeName, partitionedArgs[0], partitionedArgs[1]);
+        let [contexts, queryParams] = extractQueryParams(args);
+        return this.isActiveIntent(routeName, contexts, queryParams);
     }
     trigger(name, ...args) {
         this.triggerEvent(this.currentRouteInfos, false, name, args);
@@ -1917,6 +1950,7 @@ function routeInfosEqual(routeInfos, otherRouteInfos) {
         return false;
     }
     for (let i = 0, len = routeInfos.length; i < len; ++i) {
+        // SAFETY: Just casting for comparison
         if (routeInfos[i] !== otherRouteInfos[i]) {
             return false;
         }
@@ -1938,11 +1972,12 @@ function routeInfosSameExceptQueryParams(routeInfos, otherRouteInfos) {
     return true;
 }
 function paramsEqual(params, otherParams) {
-    if (!params && !otherParams) {
+    if (params === otherParams) {
+        // Both identical or both undefined
         return true;
     }
-    else if ((!params && !!otherParams) || (!!params && !otherParams)) {
-        // one is falsy but other is not;
+    if (!params || !otherParams) {
+        // One is falsy but other is not
         return false;
     }
     let keys = Object.keys(params);