Kill RegistryProxy Mixin

Author: wagenet

broccoli/amd-compat-entrypoints/ember.debug.js

@@ -56,12 +56,6 @@ d('@ember/-internals/runtime/index', emberinternalsRuntimeIndex);
 import * as emberinternalsRuntimeLibExtRsvp from '@ember/-internals/runtime/lib/ext/rsvp';
 d('@ember/-internals/runtime/lib/ext/rsvp', emberinternalsRuntimeLibExtRsvp);
 
-import * as emberinternalsRuntimeLibMixinsRegistryProxy from '@ember/-internals/runtime/lib/mixins/registry_proxy';
-d(
-  '@ember/-internals/runtime/lib/mixins/registry_proxy',
-  emberinternalsRuntimeLibMixinsRegistryProxy
-);
-
 import * as emberinternalsStringIndex from '@ember/-internals/string/index';
 d('@ember/-internals/string/index', emberinternalsStringIndex);
 

package.json

@@ -205,7 +205,6 @@
       "@ember/-internals/routing/index.js": "ember-source/@ember/-internals/routing/index.js",
       "@ember/-internals/runtime/index.js": "ember-source/@ember/-internals/runtime/index.js",
       "@ember/-internals/runtime/lib/ext/rsvp.js": "ember-source/@ember/-internals/runtime/lib/ext/rsvp.js",
-      "@ember/-internals/runtime/lib/mixins/registry_proxy.js": "ember-source/@ember/-internals/runtime/lib/mixins/registry_proxy.js",
       "@ember/-internals/string/index.js": "ember-source/@ember/-internals/string/index.js",
       "@ember/-internals/utility-types/index.js": "ember-source/@ember/-internals/utility-types/index.js",
       "@ember/-internals/utils/index.js": "ember-source/@ember/-internals/utils/index.js",

packages/@ember/-internals/runtime/index.ts

@@ -1,3 +1 @@
-export { default as RegistryProxyMixin } from './lib/mixins/registry_proxy';
-
 export { default as RSVP, onerrorDefault } from './lib/ext/rsvp'; // just for side effect of extending Ember.RSVP

packages/@ember/-internals/runtime/lib/mixins/registry_proxy.ts

@@ -14,7 +14,8 @@ import EngineInstance from '@ember/engine/instance';
 import { RoutingService } from '@ember/routing/-internals';
 import { ComponentLookup } from '@ember/-internals/views';
 import { setupEngineRegistry } from '@ember/-internals/glimmer';
-import { RegistryProxyMixin } from '@ember/-internals/runtime';
+import type { FullName, RegisterOptions } from '@ember/owner';
+import type { FactoryClass, InternalFactory } from '@ember/-internals/owner';
 
 function props(obj: object) {
   let properties = [];
@@ -50,12 +51,9 @@ export interface Initializer<T> {
 
   @class Engine
   @extends Ember.Namespace
-  @uses RegistryProxyMixin
   @public
 */
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
-interface Engine extends RegistryProxyMixin {}
-class Engine extends Namespace.extend(RegistryProxyMixin) {
+class Engine extends Namespace {
   static initializers: Record<string, Initializer<Engine>> = Object.create(null);
   static instanceInitializers: Record<string, Initializer<EngineInstance>> = Object.create(null);
 
@@ -443,6 +441,79 @@ class Engine extends Namespace.extend(RegistryProxyMixin) {
 
     graph.topsort(cb);
   }
+
+  // Registry Proxy
+  // Duplicated with EngineInstance
+
+  declare __registry__: Registry;
+
+  resolveRegistration(fullName: string) {
+    assert('fullName must be a proper full name', this.__registry__.isValidFullName(fullName));
+    return this.__registry__.resolve(fullName);
+  }
+
+  register<T extends object, C extends FactoryClass | object>(
+    fullName: FullName,
+    factory: InternalFactory<T, C>,
+    options: RegisterOptions & { instantiate: true }
+  ): void;
+  register(fullName: FullName, factory: object, options?: RegisterOptions): void;
+  register<T extends object, C extends FactoryClass | object>(
+    fullName: FullName,
+    factory: InternalFactory<T, C>,
+    options?: RegisterOptions
+  ): void;
+  register(...args: Parameters<Registry['register']>) {
+    return this.__registry__.register(...args);
+  }
+
+  /**
+   Unregister a fullName
+   */
+  unregister(fullName: FullName) {
+    this.__registry__.unregister(fullName);
+  }
+
+  /**
+   Given a fullName check if the registry is aware of its factory
+   or singleton instance.
+
+   @private
+   @method hasRegistration
+   @param {String} fullName
+   @param {Object} [options]
+   @param {String} [options.source] the fullname of the request source (used for local lookups)
+   @return {Boolean}
+   */
+  hasRegistration(fullName: FullName): boolean {
+    return this.__registry__.has(fullName);
+  }
+
+  registeredOption<K extends keyof RegisterOptions>(
+    fullName: FullName,
+    optionName: K
+  ): RegisterOptions[K] | undefined {
+    return this.__registry__.getOption(fullName, optionName);
+  }
+
+  registerOptions(fullName: FullName, options: RegisterOptions) {
+    return this.__registry__.options(fullName, options);
+  }
+
+  registeredOptions(fullName: FullName): RegisterOptions | undefined {
+    return this.__registry__.getOptions(fullName);
+  }
+
+  /**
+   Allow registering options for all factories of a type.
+   */
+  registerOptionsForType(type: string, options: RegisterOptions) {
+    return this.__registry__.optionsForType(type, options);
+  }
+
+  registeredOptionsForType(type: string): RegisterOptions | undefined {
+    return this.__registry__.getOptionsForType(type);
+  }
 }
 
 /**

packages/@ember/engine/index.ts

@@ -10,8 +10,13 @@ import type { Container } from '@ember/-internals/container';
 import { Registry, privatize as P } from '@ember/-internals/container';
 import { guidFor } from '@ember/-internals/utils';
 import { ENGINE_PARENT, getEngineParent, setEngineParent } from './parent';
-import { RegistryProxyMixin } from '@ember/-internals/runtime';
-import type { ContainerProxy, InternalOwner, RegisterOptions } from '@ember/-internals/owner';
+import type {
+  ContainerProxy,
+  FactoryClass,
+  InternalFactory,
+  InternalOwner,
+  RegisterOptions,
+} from '@ember/-internals/owner';
 import type Owner from '@ember/-internals/owner';
 import { type FullName, isFactory } from '@ember/-internals/owner';
 import type Engine from '@ember/engine';
@@ -42,7 +47,6 @@ export interface EngineInstanceOptions {
   @public
   @class EngineInstance
   @extends EmberObject
-  @uses RegistryProxyMixin
 */
 
 // TODO: Update this comment
@@ -53,11 +57,9 @@ export interface EngineInstanceOptions {
 // clauses for `InternalOwner` and `Owner` is to keep us honest: if this stops
 // type checking, we have broken part of our public API contract. Medium-term,
 // the goal here is to `EngineInstance` simple be `Owner`.
-interface EngineInstance extends RegistryProxyMixin, InternalOwner, Owner {}
-class EngineInstance
-  extends EmberObject.extend(RegistryProxyMixin)
-  implements ContainerProxy, InternalOwner, Owner
-{
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface EngineInstance extends Owner {}
+class EngineInstance extends EmberObject implements ContainerProxy, InternalOwner, Owner {
   /**
    @private
    @method setupRegistry
@@ -174,23 +176,6 @@ class EngineInstance
     (this.constructor as typeof EngineInstance).setupRegistry(this.__registry__, options);
   }
 
-  /**
-   Unregister a factory.
-
-   Overrides `RegistryProxy#unregister` in order to clear any cached instances
-   of the unregistered factory.
-
-   @public
-   @method unregister
-   @param {String} fullName
-   */
-  unregister(fullName: FullName) {
-    this.__container__.reset(fullName);
-
-    // We overwrote this method from RegistryProxyMixin.
-    this.__registry__.unregister(fullName);
-  }
-
   /**
     Build a new `EngineInstance` that's a child of this instance.
 
@@ -288,6 +273,92 @@ class EngineInstance
 
     return super.destroy();
   }
+
+  // Registry Proxy
+  // Duplicated with Engine
+
+  declare __registry__: Registry;
+
+  resolveRegistration(fullName: string) {
+    assert('fullName must be a proper full name', this.__registry__.isValidFullName(fullName));
+    return this.__registry__.resolve(fullName);
+  }
+
+  /**
+   Registers a factory for later injection.
+
+   @private
+   @method register
+   @param {String} fullName
+   @param {Function} factory
+   @param {Object} options
+   */
+  register<T extends object, C extends FactoryClass | object>(
+    fullName: FullName,
+    factory: InternalFactory<T, C>,
+    options: RegisterOptions & { instantiate: true }
+  ): void;
+  register(fullName: FullName, factory: object, options?: RegisterOptions): void;
+  register(...args: Parameters<Registry['register']>) {
+    return this.__registry__.register(...args);
+  }
+
+  /**
+   Unregister a factory.
+
+   Also clears any cached instances of the unregistered factory.
+
+   @public
+   @method unregister
+   @param {String} fullName
+   */
+  unregister(fullName: FullName) {
+    this.__container__.reset(fullName);
+
+    // We overwrote this method from RegistryProxyMixin.
+    this.__registry__.unregister(fullName);
+  }
+
+  /**
+   Given a fullName check if the registry is aware of its factory
+   or singleton instance.
+
+   @private
+   @method hasRegistration
+   @param {String} fullName
+   @param {Object} [options]
+   @param {String} [options.source] the fullname of the request source (used for local lookups)
+   @return {Boolean}
+   */
+  hasRegistration(fullName: FullName): boolean {
+    return this.__registry__.has(fullName);
+  }
+
+  registeredOption<K extends keyof RegisterOptions>(
+    fullName: FullName,
+    optionName: K
+  ): RegisterOptions[K] | undefined {
+    return this.__registry__.getOption(fullName, optionName);
+  }
+
+  registerOptions(fullName: FullName, options: RegisterOptions) {
+    return this.__registry__.options(fullName, options);
+  }
+
+  registeredOptions(fullName: FullName): RegisterOptions | undefined {
+    return this.__registry__.getOptions(fullName);
+  }
+
+  /**
+   Allow registering options for all factories of a type.
+   */
+  registerOptionsForType(type: string, options: RegisterOptions) {
+    return this.__registry__.optionsForType(type, options);
+  }
+
+  registeredOptionsForType(type: string): RegisterOptions | undefined {
+    return this.__registry__.getOptionsForType(type);
+  }
 }
 
 // MEGAHAX: This is really nasty, but if we don't define the functions this way, we need to provide types.

packages/@ember/engine/instance.ts

@@ -1,11 +1,12 @@
 import type { ResolverClass } from '@ember/-internals/container/lib/registry';
-import type { default as Owner, RegisterOptions, Factory } from '@ember/owner';
+import type { default as Owner, RegisterOptions } from '@ember/owner';
 import type Namespace from '@ember/application/namespace';
 import type { Initializer } from '@ember/engine';
 import Engine from '@ember/engine';
 import type EngineInstance from '@ember/engine/instance';
 import EmberObject from '@ember/object';
 import { expectTypeOf } from 'expect-type';
+import { InternalFactory } from '@ember/-internals/owner';
 
 declare let owner: Owner;
 
@@ -37,7 +38,8 @@ expectTypeOf(engine.Resolver).toEqualTypeOf<ResolverClass>();
 // RegistryProxy
 
 expectTypeOf(engine.resolveRegistration('foo:bar')).toEqualTypeOf<
-  Factory<object> | object | undefined
+  // NOTE: The original tests had Factory here. It seems like Factory should match InternalFactory...
+  InternalFactory<object> | object | undefined
 >();
 // @ts-expect-error Requires name
 engine.resolveRegistration();

packages/@ember/engine/type-tests/index.test.ts

@@ -41,7 +41,7 @@ import {
   sendEvent as emberSendEvent,
 } from '@ember/object/events';
 
-import { RegistryProxyMixin, RSVP as _RSVP } from '@ember/-internals/runtime';
+import { RSVP as _RSVP } from '@ember/-internals/runtime';
 import {
   componentCapabilities,
   modifierCapabilities,
@@ -160,9 +160,6 @@ namespace Ember {
   export const hasListeners = metal.hasListeners;
   export const libraries = metal.libraries;
 
-  // ****@ember/-internals/runtime****
-  export const _RegistryProxyMixin = RegistryProxyMixin;
-
   // ****@ember/-internals/view****
   export const ComponentLookup = views.ComponentLookup;
   export const EventDispatcher = views.EventDispatcher;