Remove Ember.Comparable

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

@@ -1,6 +1,5 @@
 export { default as RegistryProxyMixin } from './lib/mixins/registry_proxy';
 export { default as ContainerProxyMixin } from './lib/mixins/container_proxy';
-export { default as Comparable } from './lib/mixins/comparable';
 export { default as ActionHandler } from './lib/mixins/action_handler';
 export { default as _ProxyMixin, contentFor as _contentFor } from './lib/mixins/-proxy';
 export { default as MutableEnumerable } from '@ember/enumerable/mutable';

packages/@ember/utils/lib/compare.ts

@@ -1,6 +1,5 @@
 import type { TypeName } from './type-of';
 import typeOf from './type-of';
-import { Comparable } from '@ember/-internals/runtime';
 import { assert } from '@ember/debug';
 
 const TYPE_ORDER: Record<TypeName, number> = {
@@ -104,11 +103,11 @@ export default function compare<T>(v: T, w: T): Compare {
   let type1 = typeOf(v);
   let type2 = typeOf(w);
 
-  if (type1 === 'instance' && isComparable(v) && v.constructor.compare) {
+  if (type1 === 'instance' && hasConstructorCompare(v)) {
     return v.constructor.compare(v, w);
   }
 
-  if (type2 === 'instance' && isComparable(w) && w.constructor.compare) {
+  if (type2 === 'instance' && hasConstructorCompare(w)) {
     // SAFETY: Multiplying by a negative just changes the sign
     return (w.constructor.compare(w, v) * -1) as Compare;
   }
@@ -149,7 +148,7 @@ export default function compare<T>(v: T, w: T): Compare {
       return spaceship(vLen, wLen);
     }
     case 'instance':
-      if (isComparable(v) && v.compare) {
+      if (hasInstanceCompare(v)) {
         return v.compare(v, w);
       }
       return 0;
@@ -163,10 +162,27 @@ export default function compare<T>(v: T, w: T): Compare {
   }
 }
 
-interface ComparableConstructor {
-  constructor: Comparable;
+interface WithConstructorCompare {
+  constructor: { compare: (a: unknown, b: unknown) => Compare };
 }
 
-function isComparable(value: unknown): value is Comparable & ComparableConstructor {
-  return Comparable.detect(value);
+interface WithInstanceCompare {
+  compare: (a: unknown, b: unknown) => Compare;
 }
+
+function hasConstructorCompare(value: unknown): value is WithConstructorCompare {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    typeof (value as WithConstructorCompare).constructor?.compare === 'function'
+  );
+}
+
+function hasInstanceCompare(value: unknown): value is WithInstanceCompare {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    typeof (value as WithInstanceCompare).compare === 'function'
+  );
+}
+

packages/@ember/utils/tests/compare_test.js

@@ -1,10 +1,9 @@
 import { compare, typeOf } from '@ember/utils';
 import EmberObject from '@ember/object';
-import { Comparable } from '@ember/-internals/runtime';
 import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
 
 let data = [];
-let Comp = EmberObject.extend(Comparable);
+let Comp = EmberObject.extend();
 
 Comp.reopenClass({
   compare(obj) {
@@ -64,17 +63,9 @@ moduleFor(
     }
 
     ['@test comparables should return values in the range of -1, 0, 1'](assert) {
-      let negOne = Comp.create({
-        val: -1,
-      });
-
-      let zero = Comp.create({
-        val: 0,
-      });
-
-      let one = Comp.create({
-        val: 1,
-      });
+      let negOne = Comp.create({ val: -1 });
+      let zero = Comp.create({ val: 0 });
+      let one = Comp.create({ val: 1 });
 
       assert.equal(compare(negOne, 'a'), -1, 'First item comparable - returns -1 (not negated)');
       assert.equal(compare(zero, 'b'), 0, 'First item comparable - returns  0 (not negated)');

packages/ember/barrel.ts

@@ -49,7 +49,6 @@ import {
   ContainerProxyMixin,
   _ProxyMixin as internalProxyMixin,
   RSVP as _RSVP,
-  Comparable as InternalComparable,
   ActionHandler as InternalActionHandler,
 } from '@ember/-internals/runtime';
 import {
@@ -189,8 +188,6 @@ namespace Ember {
   export const _RegistryProxyMixin = RegistryProxyMixin;
   export const ActionHandler = InternalActionHandler;
   export type ActionHandler = InternalActionHandler;
-  export const Comparable = InternalComparable;
-  export type Comparable = InternalComparable;
 
   // ****@ember/-internals/view****
   export const ComponentLookup = views.ComponentLookup;

packages/ember/tests/reexports_test.js

@@ -342,7 +342,6 @@ let allExports = [
   ['_Input', '@ember/-internals/glimmer', 'Input', test56],
   ['_RegistryProxyMixin', '@ember/-internals/runtime', 'RegistryProxyMixin', test57],
   ['_ContainerProxyMixin', '@ember/-internals/runtime', 'ContainerProxyMixin', test57],
-  ['Comparable', '@ember/-internals/runtime', null, test57],
   ['ActionHandler', '@ember/-internals/runtime', null, test57],
   ['MutableEnumerable', '@ember/-internals/runtime', null, test57],
   ['_ProxyMixin', '@ember/-internals/runtime', null, test57],