ember-source 5.6.0-alpha.2 → 5.6.0-alpha.4

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

@@ -5,6 +5,7 @@ var __decorate = this && this.__decorate || function (decorators, target, key, d
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var _a;
 import { privatize as P } from '@ember/-internals/container';
 import { addObserver, defineProperty, descriptorForProperty, flushAsyncObservers } from '@ember/-internals/metal';
 import { getOwner } from '@ember/-internals/owner';
@@ -13,7 +14,7 @@ import EmberObject, { computed, get, set, getProperties, setProperties } from '@
 import Evented from '@ember/object/evented';
 import { A as emberA } from '@ember/array';
 import { ActionHandler } from '@ember/-internals/runtime';
-import { isEmpty, typeOf } from '@ember/utils';
+import { typeOf } from '@ember/utils';
 import { isProxy, lookupDescriptor } from '@ember/-internals/utils';
 import Controller from '@ember/controller';
 import { assert, deprecate, info, isTesting } from '@ember/debug';
@@ -28,8 +29,8 @@ import { calculateCacheKey, normalizeControllerQueryParams, prefixRouteNameArg,
 function isStoreLike(store) {
   return typeof store === 'object' && store !== null && typeof store.find === 'function';
 }
-export const ROUTE_CONNECTIONS = new WeakMap();
 const RENDER = Symbol('render');
+const RENDER_STATE = Symbol('render-state');
 class Route extends EmberObject.extend(ActionHandler, Evented) {
   constructor(owner) {
     super(owner);
@@ -39,6 +40,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
     // people subclassing `Route` that they should not use them.
     /** @internal */
     this.context = {};
+    this[_a] = undefined;
     if (owner) {
       let router = owner.lookup('router:main');
       let bucketCache = owner.lookup(P`-bucket-cache:main`);
@@ -316,7 +318,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
        @method enter
   */
   enter(transition) {
-    ROUTE_CONNECTIONS.set(this, []);
+    this[RENDER_STATE] = undefined;
     this.activate(transition);
     this.trigger('activate', transition);
   }
@@ -777,24 +779,12 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
     return route?.currentModel;
   }
   /**
-    `this[RENDER]` is used to render a template into a region of another template
-    (indicated by an `{{outlet}}`).
-       @method this[RENDER]
-    @param {String} name the name of the template to render
-    @param {Object} [options] the options
-    @param {String} [options.into] the template to render into,
-                    referenced by name. Defaults to the parent template
-    @param {String} [options.outlet] the outlet inside `options.into` to render into.
-                    Defaults to 'main'
-    @param {String|Object} [options.controller] the controller to use for this template,
-                    referenced by name or as a controller instance. Defaults to the Route's paired controller
-    @param {Object} [options.model] the model object to set on `options.controller`.
-                    Defaults to the return value of the Route's model hook
+    `this[RENDER]` is used to set up the rendering option for the outlet state.
+    @method this[RENDER]
     @private
    */
-  [RENDER](name, options) {
-    let renderOptions = buildRenderOptions(this, name, options);
-    ROUTE_CONNECTIONS.get(this).push(renderOptions);
+  [(_a = RENDER_STATE, RENDER)]() {
+    this[RENDER_STATE] = buildRenderState(this);
     once(this._router, '_setOutlets');
   }
   willDestroy() {
@@ -805,9 +795,8 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
        @method teardownViews
   */
   teardownViews() {
-    let connections = ROUTE_CONNECTIONS.get(this);
-    if (connections !== undefined && connections.length > 0) {
-      ROUTE_CONNECTIONS.set(this, []);
+    if (this[RENDER_STATE]) {
+      this[RENDER_STATE] = undefined;
       once(this._router, '_setOutlets');
     }
   }
@@ -952,92 +941,25 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 Route.isRouteFactory = true;
 __decorate([computed], Route.prototype, "_store", null);
 __decorate([computed], Route.prototype, "_qp", null);
-function parentRoute(route) {
-  let routeInfo = routeInfoFor(route, route._router._routerMicrolib.state.routeInfos, -1);
-  return routeInfo && routeInfo.route;
+export function getRenderState(route) {
+  return route[RENDER_STATE];
 }
-function routeInfoFor(route, routeInfos, offset = 0) {
-  if (!routeInfos) {
-    return;
-  }
-  let current;
-  for (let i = 0; i < routeInfos.length; i++) {
-    let routeInfo = routeInfos[i];
-    assert('has current routeInfo', routeInfo);
-    current = routeInfo.route;
-    if (current === route) {
-      return routeInfos[i + offset];
-    }
-  }
-  return;
-}
-function buildRenderOptions(route, nameOrOptions, options) {
-  let isDefaultRender = !nameOrOptions && !options;
-  let _name;
-  if (!isDefaultRender) {
-    if (typeof nameOrOptions === 'object' && !options) {
-      _name = route.templateName || route.routeName;
-      options = nameOrOptions;
-    } else {
-      assert('The name in the given arguments is undefined or empty string', !isEmpty(nameOrOptions));
-      // SAFETY: the check for `nameOrOptions` above should be validating this,
-      // and as of TS 5.1.0-dev.2023-0417 it is *not*. This cast can go away if
-      // TS validates it correctly *or* if we refactor this entire function to
-      // be less wildly dynamic in its argument handling.
-      _name = nameOrOptions;
-    }
-  }
-  assert('You passed undefined as the outlet name.', isDefaultRender || !(options && 'outlet' in options && options.outlet === undefined));
+function buildRenderState(route) {
   let owner = getOwner(route);
   assert('Route is unexpectedly missing an owner', owner);
-  let name, templateName, into, outlet, model;
-  let controller;
-  if (options) {
-    into = options.into && options.into.replace(/\//g, '.');
-    outlet = options.outlet;
-    controller = options.controller;
-    model = options.model;
-  }
-  outlet = outlet || 'main';
-  if (isDefaultRender) {
-    name = route.routeName;
-    templateName = route.templateName || name;
-  } else {
-    name = _name.replace(/\//g, '.');
-    templateName = name;
-  }
-  if (controller === undefined) {
-    if (isDefaultRender) {
-      controller = route.controllerName || owner.lookup(`controller:${name}`);
-    } else {
-      controller = owner.lookup(`controller:${name}`) || route.controllerName || route.routeName;
-    }
-  }
-  if (typeof controller === 'string') {
-    let controllerName = controller;
-    controller = owner.lookup(`controller:${controllerName}`);
-    assert(`You passed \`controller: '${controllerName}'\` into the \`render\` method, but no such controller could be found.`, isDefaultRender || controller !== undefined);
-  }
+  let name = route.routeName;
+  let controller = owner.lookup(`controller:${route.controllerName || name}`);
   assert('Expected an instance of controller', controller instanceof Controller);
-  if (model === undefined) {
-    model = route.currentModel;
-  } else {
-    controller.set('model', model);
-  }
-  let template = owner.lookup(`template:${templateName}`);
-  assert(`Could not find "${templateName}" template, view, or component.`, isDefaultRender || template !== undefined);
-  let parent;
-  if (into && (parent = parentRoute(route)) && into === parent.routeName) {
-    into = undefined;
-  }
-  let renderOptions = {
+  let model = route.currentModel;
+  let template = owner.lookup(`template:${route.templateName || name}`);
+  let render = {
     owner,
-    into,
-    outlet,
+    into: undefined,
+    outlet: 'main',
     name,
     controller,
     model,
-    template: template !== undefined ? template(owner) : route._topLevelViewTemplate(owner)
+    template: template?.(owner) ?? route._topLevelViewTemplate(owner)
   };
   if (DEBUG) {
     let LOG_VIEW_LOOKUPS = get(route._router, 'namespace.LOG_VIEW_LOOKUPS');
@@ -1047,7 +969,7 @@ function buildRenderOptions(route, nameOrOptions, options) {
       });
     }
   }
-  return renderOptions;
+  return render;
 }
 export function getFullQueryParams(router, state) {
   if (state.fullQueryParams) {

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

@@ -10,7 +10,7 @@ import Evented from '@ember/object/evented';
 import { assert, info } from '@ember/debug';
 import { cancel, once, run, scheduleOnce } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
-import { defaultSerialize, getFullQueryParams, hasDefaultSerialize, ROUTE_CONNECTIONS } from '@ember/routing/route';
+import { defaultSerialize, getFullQueryParams, getRenderState, hasDefaultSerialize } from '@ember/routing/route';
 import Router, { logAbort, STATE_SYMBOL } from 'router_js';
 import EngineInstance from '@ember/engine/instance';
 /**
@@ -400,35 +400,39 @@ class EmberRouter extends EmberObject.extend(Evented) {
     if (!routeInfos) {
       return;
     }
-    let defaultParentState;
-    let liveRoutes = null;
+    let root = null;
+    let parent = null;
     for (let routeInfo of routeInfos) {
       let route = routeInfo.route;
-      let connections = ROUTE_CONNECTIONS.get(route);
-      let ownState;
-      if (connections.length === 0) {
-        ownState = representEmptyRoute(liveRoutes, defaultParentState, route);
-      } else {
-        for (let j = 0; j < connections.length; j++) {
-          let appended = appendLiveRoute(liveRoutes, defaultParentState, connections[j]);
-          liveRoutes = appended.liveRoutes;
-          let {
-            name,
-            outlet
-          } = appended.ownState.render;
-          if (name === route.routeName || outlet === 'main') {
-            ownState = appended.ownState;
+      let render = getRenderState(route);
+      if (render) {
+        let state = {
+          render,
+          outlets: {
+            main: undefined
           }
+        };
+        if (parent) {
+          parent.outlets.main = state;
+        } else {
+          root = state;
         }
+        parent = state;
+      } else {
+        // It used to be that we would create a stub entry and keep traversing,
+        // but I don't think that is necessary anymore – if a parent route did
+        // not render, then the child routes have nowhere to render into these
+        // days. That wasn't always the case since in the past any route can
+        // render into any other route's outlets.
+        break;
       }
-      defaultParentState = ownState;
     }
     // when a transitionTo happens after the validation phase
     // during the initial transition _setOutlets is called
     // when no routes are active. However, it will get called
     // again with the correct values during the next turn of
     // the runloop
-    if (!liveRoutes) {
+    if (root === null) {
       return;
     }
     if (!this._toplevelView) {
@@ -451,7 +455,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
         template,
         application
       });
-      this._toplevelView.setOutletState(liveRoutes);
+      this._toplevelView.setOutletState(root);
       // TODO(SAFETY): At least one test runs without this set correctly. At a
       // later time, update the test to configure this correctly. The test ID:
       // `Router Service - non application test:  RouterService#transitionTo with basic route`
@@ -465,7 +469,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
         instance.didCreateRootView(this._toplevelView);
       }
     } else {
-      this._toplevelView.setOutletState(liveRoutes);
+      this._toplevelView.setOutletState(root);
     }
   }
   handleURL(url) {
@@ -1282,69 +1286,6 @@ function forEachQueryParam(router, routeInfos, queryParams, callback) {
     callback(key, value, qp);
   }
 }
-function findLiveRoute(liveRoutes, name) {
-  if (!liveRoutes) {
-    return;
-  }
-  let stack = [liveRoutes];
-  while (stack.length > 0) {
-    let test = stack.shift();
-    if (test.render.name === name) {
-      return test;
-    }
-    let outlets = test.outlets;
-    for (let outletName in outlets) {
-      stack.push(outlets[outletName]);
-    }
-  }
-  return;
-}
-function appendLiveRoute(liveRoutes, defaultParentState, renderOptions) {
-  let ownState = {
-    render: renderOptions,
-    outlets: Object.create(null),
-    wasUsed: false
-  };
-  let target;
-  if (renderOptions.into) {
-    target = findLiveRoute(liveRoutes, renderOptions.into);
-  } else {
-    target = defaultParentState;
-  }
-  if (target) {
-    set(target.outlets, renderOptions.outlet, ownState);
-  } else {
-    liveRoutes = ownState;
-  }
-  return {
-    liveRoutes,
-    ownState
-  };
-}
-function representEmptyRoute(liveRoutes, defaultParentState, {
-  routeName
-}) {
-  // the route didn't render anything
-  let alreadyAppended = findLiveRoute(liveRoutes, routeName);
-  if (alreadyAppended) {
-    // But some other route has already rendered our default
-    // template, so that becomes the default target for any
-    // children we may have.
-    return alreadyAppended;
-  } else {
-    // Create an entry to represent our default template name,
-    // just so other routes can target it and inherit its place
-    // in the outlet hierarchy.
-    defaultParentState.outlets['main'] = {
-      render: {
-        name: routeName,
-        outlet: 'main'
-      },
-      outlets: {}
-    };
-    return defaultParentState;
-  }
-}
 EmberRouter.reopen({
   didTransition: defaultDidTransition,
   willTransition: defaultWillTransition,

package/dist/packages/ember/version.js

@@ -1 +1 @@
-export default "5.6.0-alpha.2";
+export default "5.6.0-alpha.4";

package/dist/packages/ember-babel.js

@@ -9,6 +9,19 @@ const hasReflectConstruct = typeof Reflect === 'object' && typeof Reflect.constr
 
 const nativeWrapperCache = new Map();
 
+// Implementations:
+// https://github.com/babel/babel/blob/436d78920883603668666210a4aacf524257bc3b/packages/babel-helpers/src/helpers.ts#L958
+let privateFieldId = 0;
+export function classPrivateFieldLooseKey(name) {
+  return '__private_' + privateFieldId++ + '_' + name;
+}
+export function classPrivateFieldLooseBase(receiver, privateKey) {
+  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+    throw new TypeError('attempted to use private field on non-instance');
+  }
+  return receiver;
+}
+
 // Super minimal version of Babel's wrapNativeSuper. We only use this for
 // extending Function, for ComputedDecoratorImpl and AliasDecoratorImpl. We know
 // we will never directly create an instance of these classes so no need to