Merge pull request #21459 from emberjs/nvp/make-renderComponent-demo-even-smaller

Reducing hello-world size

Author: NullVoxPopuli

package.json

@@ -211,6 +211,7 @@
       "@ember/application/namespace.js": "ember-source/@ember/application/namespace.js",
       "@ember/array/-internals.js": "ember-source/@ember/array/-internals.js",
       "@ember/array/index.js": "ember-source/@ember/array/index.js",
+      "@ember/array/lib/is-array.js": "ember-source/@ember/array/lib/is-array.js",
       "@ember/array/lib/make-array.js": "ember-source/@ember/array/lib/make-array.js",
       "@ember/array/make.js": "ember-source/@ember/array/make.js",
       "@ember/array/mutable.js": "ember-source/@ember/array/mutable.js",

packages/@ember/-internals/glimmer/lib/component-managers/mount.ts

@@ -1,7 +1,7 @@
 import type { InternalOwner } from '@ember/-internals/owner';
 import { generateControllerFactory } from '@ember/routing/lib/generate_controller';
 import { assert } from '@ember/debug';
-import EngineInstance from '@ember/engine/instance';
+import type EngineInstance from '@ember/engine/instance';
 import { associateDestroyableChild } from '@glimmer/destroyable';
 import type {
   CapturedArguments,
@@ -82,8 +82,8 @@ class MountManager
     // we should resolve the engine app template in the helper
     // it also should use the owner that looked up the mount helper.
 
-    assert('Expected owner to be an EngineInstance', owner instanceof EngineInstance);
-    let engine = owner.buildChildEngineInstance(name);
+    assert('Expected owner to be an EngineInstance', 'buildChildEngineInstance' in owner);
+    let engine = (owner as EngineInstance).buildChildEngineInstance(name);
 
     engine.boot();
 

packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts

@@ -1,7 +1,7 @@
 import type { InternalOwner } from '@ember/-internals/owner';
 import type { Nullable } from '@ember/-internals/utility-types';
 import { assert } from '@ember/debug';
-import EngineInstance from '@ember/engine/instance';
+import type EngineInstance from '@ember/engine/instance';
 import { _instrumentStart } from '@ember/instrumentation';
 import { precompileTemplate } from '@ember/template-compilation';
 import type {
@@ -97,15 +97,16 @@ class OutletComponentManager
       if (parentOwner && parentOwner !== currentOwner) {
         assert(
           'Expected currentOwner to be an EngineInstance',
-          currentOwner instanceof EngineInstance
+          currentOwner != null && 'buildChildEngineInstance' in currentOwner
         );
 
-        let { mountPoint } = currentOwner;
+        let engineInstance = currentOwner as EngineInstance;
+        let { mountPoint } = engineInstance;
 
         if (mountPoint) {
           state.engine = {
             mountPoint,
-            instance: currentOwner,
+            instance: engineInstance,
           };
         }
       }

packages/@ember/-internals/glimmer/lib/renderer.ts

@@ -44,7 +44,6 @@ import { dict } from '@glimmer/util/lib/collections';
 import { unwrapTemplate } from './component-managers/unwrap-template';
 import { CURRENT_TAG, validateTag, valueForTag } from '@glimmer/validator/lib/validators';
 import type { SimpleDocument, SimpleElement, SimpleNode } from '@simple-dom/interface';
-import RSVP from 'rsvp';
 import type Component from './component';
 import { hasDOM } from '../../browser-environment';
 import type ClassicComponent from './component';
@@ -293,7 +292,12 @@ function loopBegin(): void {
   }
 }
 
-let renderSettledDeferred: RSVP.Deferred<void> | null = null;
+interface RenderSettledDeferred {
+  promise: Promise<void>;
+  resolve: () => void;
+}
+
+let renderSettledDeferred: RenderSettledDeferred | null = null;
 /*
   Returns a promise which will resolve when rendering has settled. Settled in
   this context is defined as when all of the tags in use are "current" (e.g.
@@ -305,7 +309,9 @@ let renderSettledDeferred: RSVP.Deferred<void> | null = null;
 */
 export function renderSettled() {
   if (renderSettledDeferred === null) {
-    renderSettledDeferred = RSVP.defer();
+    let resolve!: () => void;
+    let promise = new Promise<void>((r) => (resolve = r));
+    renderSettledDeferred = { promise, resolve };
     // if there is no current runloop, the promise created above will not have
     // a chance to resolve (because its resolved in backburner's "end" event)
     if (!_getCurrentRunLoop()) {

packages/@ember/-internals/glimmer/lib/utils/to-bool.ts

@@ -1,7 +1,7 @@
 import { isHTMLSafe } from './string';
 import { get } from '@ember/-internals/metal/lib/property_get';
 import { tagForProperty } from '@ember/-internals/metal/lib/tags';
-import { isArray } from '@ember/array';
+import isArray from '@ember/array/lib/is-array';
 import { isProxy } from '@ember/-internals/utils/lib/is_proxy';
 import { consumeTag } from '@glimmer/validator/lib/tracking';
 

packages/@ember/array/index.ts

@@ -1,8 +1,6 @@
 /**
 @module @ember/array
 */
-import { DEBUG } from '@glimmer/env';
-import { PROXY_CONTENT } from '@ember/-internals/metal/lib/property_get';
 import { objectAt } from '@ember/-internals/metal/lib/object-at';
 import { replaceInNativeArray, replace } from '@ember/-internals/metal/lib/array';
 import computed from '@ember/-internals/metal/lib/computed';
@@ -17,11 +15,11 @@ import { assert } from '@ember/debug';
 import Enumerable from '@ember/enumerable';
 import MutableEnumerable from '@ember/enumerable/mutable';
 import compare from '@ember/utils/lib/compare';
-import typeOf from '@ember/utils/lib/type-of';
 import Observable from '@ember/object/observable';
 import type { MethodNamesOf, MethodParams, MethodReturns } from '@ember/-internals/utility-types';
 import type { ComputedPropertyCallback } from '@ember/-internals/metal/lib/computed';
 import { isEmberArray, setEmberArray } from '@ember/array/-internals';
+import isArray from './lib/is-array';
 
 export { default as makeArray } from './make';
 
@@ -137,65 +135,7 @@ function insertAt<T>(array: MutableArray<T>, index: number, item: T) {
   return item;
 }
 
-/**
-  Returns true if the passed object is an array or Array-like.
-
-  Objects are considered Array-like if any of the following are true:
-
-    - the object is a native Array
-    - the object has an objectAt property
-    - the object is an Object, and has a length property
-
-  Unlike `typeOf` this method returns true even if the passed object is
-  not formally an array but appears to be array-like (i.e. implements `Array`)
-
-  ```javascript
-  import { isArray } from '@ember/array';
-  import ArrayProxy from '@ember/array/proxy';
-
-  isArray();                                      // false
-  isArray([]);                                    // true
-  isArray(ArrayProxy.create({ content: [] }));    // true
-  ```
-
-  @method isArray
-  @static
-  @for @ember/array
-  @param {Object} obj The object to test
-  @return {Boolean} true if the passed object is an array or Array-like
-  @public
-*/
-export function isArray(obj: unknown): obj is ArrayLike<unknown> | EmberArray<unknown> {
-  if (DEBUG && typeof obj === 'object' && obj !== null) {
-    // SAFETY: Property read checks are safe if it's an object
-    let possibleProxyContent = (obj as any)[PROXY_CONTENT];
-    if (possibleProxyContent !== undefined) {
-      obj = possibleProxyContent;
-    }
-  }
-
-  // SAFETY: Property read checks are safe if it's an object
-  if (!obj || (obj as any).setInterval) {
-    return false;
-  }
-
-  if (Array.isArray(obj) || EmberArray.detect(obj)) {
-    return true;
-  }
-
-  let type = typeOf(obj);
-  if ('array' === type) {
-    return true;
-  }
-
-  // SAFETY: Property read checks are safe if it's an object
-  let length = (obj as any).length;
-  if (typeof length === 'number' && length === length && 'object' === type) {
-    return true;
-  }
-
-  return false;
-}
+export { isArray };
 
 /*
   This allows us to define computed properties that are not enumerable.

packages/@ember/array/lib/is-array.ts

@@ -0,0 +1,73 @@
+import { DEBUG } from '@glimmer/env';
+import { PROXY_CONTENT } from '@ember/-internals/metal/lib/property_get';
+import typeOf from '@ember/utils/lib/type-of';
+import { isEmberArray } from '@ember/array/-internals';
+import type EmberArray from '@ember/array';
+
+/**
+ @module @ember/array
+*/
+
+/**
+  Returns true if the passed object is an array or Array-like.
+
+  Objects are considered Array-like if any of the following are true:
+
+    - the object is a native Array
+    - the object has an objectAt property
+    - the object is an Object, and has a length property
+
+  Unlike `typeOf` this method returns true even if the passed object is
+  not formally an array but appears to be array-like (i.e. implements `Array`)
+
+  ```javascript
+  import { isArray } from '@ember/array';
+  import ArrayProxy from '@ember/array/proxy';
+
+  isArray();                                      // false
+  isArray([]);                                    // true
+  isArray(ArrayProxy.create({ content: [] }));    // true
+  ```
+
+  @method isArray
+  @static
+  @for @ember/array
+  @param {Object} obj The object to test
+  @return {Boolean} true if the passed object is an array or Array-like
+  @public
+*/
+export default function isArray(obj: unknown): obj is ArrayLike<unknown> | EmberArray<unknown> {
+  if (DEBUG && typeof obj === 'object' && obj !== null) {
+    // SAFETY: Property read checks are safe if it's an object
+    let possibleProxyContent = (obj as any)[PROXY_CONTENT];
+    if (possibleProxyContent !== undefined) {
+      obj = possibleProxyContent;
+    }
+  }
+
+  // SAFETY: Property read checks are safe if it's an object
+  if (!obj || (obj as any).setInterval) {
+    return false;
+  }
+
+  // EmberArray's `init` brands every instance via `setEmberArray`; the only
+  // unbranded EmberArray objects are native arrays upgraded by `A()`, which
+  // `Array.isArray` catches. So this matches `EmberArray.detect` without
+  // pulling in the mixin's module.
+  if (Array.isArray(obj) || isEmberArray(obj)) {
+    return true;
+  }
+
+  let type = typeOf(obj);
+  if ('array' === type) {
+    return true;
+  }
+
+  // SAFETY: Property read checks are safe if it's an object
+  let length = (obj as any).length;
+  if (typeof length === 'number' && length === length && 'object' === type) {
+    return true;
+  }
+
+  return false;
+}

packages/@ember/routing/lib/generate_controller.ts

@@ -1,6 +1,6 @@
 import { get } from '@ember/-internals/metal/lib/property_get';
 import type { InternalFactory, default as Owner } from '@ember/-internals/owner';
-import Controller from '@ember/controller';
+import type Controller from '@ember/controller';
 import { assert, info } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 
@@ -65,8 +65,8 @@ export default function generateController(owner: Owner, controllerName: string)
   generateControllerFactory(owner, controllerName);
 
   let fullName = `controller:${controllerName}` as const;
-  let instance = owner.lookup(fullName);
-  assert('Expected an instance of controller', instance instanceof Controller);
+  let instance = owner.lookup(fullName) as Controller;
+  assert('Expected an instance of controller', instance != null && instance.isController === true);
 
   if (DEBUG) {
     if (get(instance, 'namespace.LOG_ACTIVE_GENERATION')) {

tests/node-vitest/tree-shakability.test.js

@@ -131,6 +131,7 @@ it('[dev] has expected tree-shakable entrypoints', async () => {
       "ember-source/@ember/application/instance.js",
       "ember-source/@ember/application/namespace.js",
       "ember-source/@ember/array/index.js",
+      "ember-source/@ember/array/lib/is-array.js",
       "ember-source/@ember/array/mutable.js",
       "ember-source/@ember/array/proxy.js",
       "ember-source/@ember/canary-features/index.js",
@@ -335,6 +336,7 @@ it('[prod] has expected tree-shakable entrypoints', async () => {
       "ember-source/@ember/application/instance.js",
       "ember-source/@ember/application/namespace.js",
       "ember-source/@ember/array/index.js",
+      "ember-source/@ember/array/lib/is-array.js",
       "ember-source/@ember/array/mutable.js",
       "ember-source/@ember/array/proxy.js",
       "ember-source/@ember/canary-features/index.js",