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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-source",
-  "version": "6.3.0-alpha.2",
+  "version": "6.3.0-alpha.4",
   "description": "A JavaScript framework for creating ambitious web applications",
   "keywords": [
     "ember-addon"
@@ -399,7 +399,7 @@
     "node": "16.20.0",
     "pnpm": "8.10.0"
   },
-  "_originalVersion": "6.3.0-alpha.2",
+  "_originalVersion": "6.3.0-alpha.4",
   "_versionPreviouslyCalculated": true,
   "publishConfig": {
     "tag": "alpha"

package/types/stable/@ember/-internals/glimmer/lib/component-managers/outlet.d.ts

@@ -1,44 +1,38 @@
 declare module '@ember/-internals/glimmer/lib/component-managers/outlet' {
   import type { InternalOwner } from '@ember/-internals/owner';
+  import type { Nullable } from '@ember/-internals/utility-types';
   import EngineInstance from '@ember/engine/instance';
   import type {
-    CapturedArguments,
     CompilableProgram,
     ComponentDefinition,
-    CapabilityMask,
     CustomRenderNode,
     Destroyable,
     Environment,
     InternalComponentCapabilities,
-    Template,
     VMArguments,
     WithCreateInstance,
     WithCustomDebugRenderTree,
   } from '@glimmer/interfaces';
-  import type { Nullable } from '@ember/-internals/utility-types';
   import type { Reference } from '@glimmer/reference';
   import type { DynamicScope } from '@ember/-internals/glimmer/lib/renderer';
   import type { OutletState } from '@ember/-internals/glimmer/lib/utils/outlet';
   import type OutletView from '@ember/-internals/glimmer/lib/views/outlet';
   interface OutletInstanceState {
-    self: Reference;
-    outletBucket?: {};
-    engineBucket?: {
+    engine?: {
+      instance: EngineInstance;
       mountPoint: string;
     };
-    engine?: EngineInstance;
     finalize: () => void;
   }
   export interface OutletDefinitionState {
     ref: Reference<OutletState | undefined>;
     name: string;
-    template: Template;
+    template: object;
     controller: unknown;
-    model: unknown;
   }
   class OutletComponentManager
     implements
-      WithCreateInstance<OutletInstanceState>,
+      WithCreateInstance<OutletInstanceState, OutletDefinitionState>,
       WithCustomDebugRenderTree<OutletInstanceState, OutletDefinitionState>
   {
     create(
@@ -50,30 +44,29 @@ declare module '@ember/-internals/glimmer/lib/component-managers/outlet' {
     ): OutletInstanceState;
     getDebugName({ name }: OutletDefinitionState): string;
     getDebugCustomRenderTree(
-      definition: OutletDefinitionState,
-      state: OutletInstanceState,
-      args: CapturedArguments
+      _definition: OutletDefinitionState,
+      state: OutletInstanceState
     ): CustomRenderNode[];
     getCapabilities(): InternalComponentCapabilities;
-    getSelf({ self }: OutletInstanceState): Reference<unknown>;
+    getSelf(): Reference<any>;
     didCreate(): void;
     didUpdate(): void;
     didRenderLayout(state: OutletInstanceState): void;
     didUpdateLayout(): void;
     getDestroyable(): Nullable<Destroyable>;
   }
-  export class OutletComponentDefinition
+  export class OutletComponent
     implements
       ComponentDefinition<OutletDefinitionState, OutletInstanceState, OutletComponentManager>
   {
     state: OutletDefinitionState;
-    manager: OutletComponentManager;
     handle: number;
-    resolvedName: string;
+    resolvedName: null;
+    manager: OutletComponentManager;
+    capabilities: import('@glimmer/interfaces').CapabilityMask;
     compilable: CompilableProgram;
-    capabilities: CapabilityMask;
-    constructor(state: OutletDefinitionState, manager?: OutletComponentManager);
+    constructor(owner: InternalOwner, state: OutletDefinitionState);
   }
-  export function createRootOutlet(outletView: OutletView): OutletComponentDefinition;
+  export function createRootOutlet(outletView: OutletView): OutletComponent;
   export {};
 }

package/types/stable/@ember/-internals/glimmer/lib/component-managers/route-template.d.ts

@@ -0,0 +1,78 @@
+declare module '@ember/-internals/glimmer/lib/component-managers/route-template' {
+  import type { InternalOwner } from '@ember/-internals/owner';
+  import type {
+    CapturedArguments,
+    CompilableProgram,
+    ComponentDefinition,
+    CustomRenderNode,
+    Destroyable,
+    InternalComponentCapabilities,
+    Template,
+    VMArguments,
+    WithCreateInstance,
+    WithCustomDebugRenderTree,
+  } from '@glimmer/interfaces';
+  import type { Nullable } from '@ember/-internals/utility-types';
+  import type { Reference } from '@glimmer/reference';
+  import { type CurriedValue } from '@glimmer/runtime';
+  interface RouteTemplateInstanceState {
+    self: Reference;
+    controller: unknown;
+  }
+  export interface RouteTemplateDefinitionState {
+    name: string;
+    templateName: string;
+  }
+  class RouteTemplateManager
+    implements
+      WithCreateInstance<RouteTemplateInstanceState, RouteTemplateDefinitionState>,
+      WithCustomDebugRenderTree<RouteTemplateInstanceState, RouteTemplateDefinitionState>
+  {
+    create(
+      _owner: InternalOwner,
+      _definition: RouteTemplateDefinitionState,
+      args: VMArguments
+    ): RouteTemplateInstanceState;
+    getSelf({ self }: RouteTemplateInstanceState): Reference;
+    getDebugName({ name }: RouteTemplateDefinitionState): string;
+    getDebugCustomRenderTree(
+      { name, templateName }: RouteTemplateDefinitionState,
+      state: RouteTemplateInstanceState,
+      args: CapturedArguments
+    ): CustomRenderNode[];
+    getCapabilities(): InternalComponentCapabilities;
+    didRenderLayout(): void;
+    didUpdateLayout(): void;
+    didCreate(): void;
+    didUpdate(): void;
+    getDestroyable(): Nullable<Destroyable>;
+  }
+  /**
+   * This "upgrades" a route template into a invocable component. Conceptually
+   * it can be 1:1 for each unique `Template`, but it's also cheap to construct,
+   * so unless the stability is desirable for other reasons, it's probably not
+   * worth caching this.
+   */
+  export class RouteTemplate
+    implements
+      ComponentDefinition<
+        RouteTemplateDefinitionState,
+        RouteTemplateInstanceState,
+        RouteTemplateManager
+      >
+  {
+    handle: number;
+    resolvedName: string;
+    state: RouteTemplateDefinitionState;
+    manager: RouteTemplateManager;
+    capabilities: import('@glimmer/interfaces').CapabilityMask;
+    compilable: CompilableProgram;
+    constructor(name: string, template: Template);
+  }
+  export function makeRouteTemplate(
+    owner: InternalOwner,
+    name: string,
+    template: Template
+  ): CurriedValue;
+  export {};
+}

package/types/stable/@ember/-internals/glimmer/lib/utils/outlet.d.ts

@@ -21,9 +21,10 @@ declare module '@ember/-internals/glimmer/lib/utils/outlet' {
      */
     model: unknown;
     /**
-     * The template (the route template to use in the {{outlet}})
+     * The route's template – this is either a Template or a component, and it
+     * gets normalized during the render process.
      */
-    template: Template | undefined;
+    template: Template | object | undefined;
   }
   export interface OutletState {
     /**

package/types/stable/index.d.ts

@@ -58,6 +58,7 @@
 /// <reference path="./@ember/-internals/glimmer/lib/component-managers/mount.d.ts" />
 /// <reference path="./@ember/-internals/glimmer/lib/component-managers/outlet.d.ts" />
 /// <reference path="./@ember/-internals/glimmer/lib/component-managers/root.d.ts" />
+/// <reference path="./@ember/-internals/glimmer/lib/component-managers/route-template.d.ts" />
 /// <reference path="./@ember/-internals/glimmer/lib/component.d.ts" />
 /// <reference path="./@ember/-internals/glimmer/lib/components/abstract-input.d.ts" />
 /// <reference path="./@ember/-internals/glimmer/lib/components/input.d.ts" />